modifying bitmask to allow specifying an explicit value, and changing to uint instead of uint8

Adding more Event Log support, and modifying the loggers so they return
errors in their operational functions.

.gitignore

@@ -28,6 +28,11 @@
 
 # Test binary, built with `go test -c`
 *.test
+# But DO include the actual tests.
+!_test.go
+!*_test.go
+!*_test_*.go
+!*_test/
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out

bitmask/bitmask.go

@@ -1,11 +1,12 @@
 package bitmask
 
 // MaskBit is a flag container.
-type MaskBit uint8
+type MaskBit uint
 
 /*
 	NewMaskBit is a convenience function.
 	It will return a MaskBit with a (referenced) value of 0, so set your consts up accordingly.
+
 	It is highly recommended to set this default as a "None" flag (separate from your iotas!)
 	as shown in the example.
 */
@@ -16,6 +17,16 @@ func NewMaskBit() (m *MaskBit) {
 	return
 }
 
+// NewMaskBitExplicit is like NewMaskBit, but allows you to specify a non-zero (0x0) value.
+func NewMaskBitExplicit(value uint) (m *MaskBit) {
+
+	var v MaskBit = MaskBit(value)
+
+	m = &v
+
+	return
+}
+
 // HasFlag is true if m has MaskBit flag set/enabled.
 func (m *MaskBit) HasFlag(flag MaskBit) (r bool) {
 
@@ -29,18 +40,32 @@ func (m *MaskBit) HasFlag(flag MaskBit) (r bool) {
 
 // AddFlag adds MaskBit flag to m.
 func (m *MaskBit) AddFlag(flag MaskBit) {
+
 	*m |= flag
+
 	return
 }
 
 // ClearFlag removes MaskBit flag from m.
 func (m *MaskBit) ClearFlag(flag MaskBit) {
+
 	*m &= flag
+
 	return
 }
 
 // ToggleFlag switches MaskBit flag in m to its inverse; if true, it is now false and vice versa.
 func (m *MaskBit) ToggleFlag(flag MaskBit) {
+
 	*m ^= flag
+
+	return
+}
+
+// Value returns the current raw uint value of a MaskBit.
+func (m *MaskBit) Value() (v uint) {
+
+	v = uint(*m)
+
 	return
 }

bitmask/doc.go

@@ -11,18 +11,18 @@ To use this, set constants like thus:
 		"r00t2.io/goutils/bitmask"
 	)
 
-	const OPTNONE types.MaskBit = 0
+	const OPTNONE bitmask.MaskBit = 0
 	const (
-		OPT1 types.MaskBit = 1 << iota
+		OPT1 bitmask.MaskBit = 1 << iota
 		OPT2
 		OPT3
 		// ...
 	)
 
-	var MyMask *MaskBit
+	var MyMask *bitmask.MaskBit
 
 	func main() {
-		MyMask = types.NewMaskBit
+		MyMask = bitmask.NewMaskBit()
 
 		MyMask.AddFlag(OPT1)
 		MyMask.AddFlag(OPT3)
@@ -41,5 +41,13 @@ As would this:
 But this would return false:
 
 	MyMask.HasFlag(OPT2)
+
+If you need something with more flexibility (as always, at the cost of complexity),
+you may be interested in one of the following libraries:
+
+. github.com/alvaroloes/enumer
+. github.com/abice/go-enum
+. github.com/jeffreyrichter/enum/enum
+
 */
 package bitmask

logging/TODO

@@ -1,11 +1,11 @@
 - Implement code line/func/etc. (only for debug?):
   https://stackoverflow.com/a/24809646
   https://golang.org/pkg/runtime/#Caller
-
-- Support simultaneous writing to multiple Loggers.
+  -- log.LlongFile and log.Lshortfile flags don't currently work properly for StdLogger/FileLogger; they refer to the file in logging package rather than the caller.
 
 - Suport remote loggers? (eventlog, syslog, systemd)
 
-- DOCS.
+- JSON logger? YAML logger? XML logger?
 
-- Unit/Integration tests.
+- DOCS.
+-- Done, but flesh out.

logging/consts_test.go

@@ -0,0 +1,39 @@
+package logging
+
+import (
+	`log`
+)
+
+/*
+	The following are strings written to the Logger in the various tests.
+	The %v is populated with the name of the type of Logger.
+*/
+const (
+	testAlert   string = "This is a test ALERT-priority log message for logger %v."
+	testCrit    string = "This is a test CRITICAL-priority (CRIT) log message for logger %v."
+	testDebug   string = "This is a test DEBUG-priority log message for logger %v."
+	testEmerg   string = "This is a test EMERGENCY-priority (EMERG) log message for logger %v."
+	testErr     string = "This is a test ERROR-priority (ERR) log message for logger %v."
+	testInfo    string = "This is a test INFO-priority log message for logger %v."
+	testNotice  string = "This is a test NOTICE-priority log message for logger %v."
+	testWarning string = "This is a test WARNING-priority log message for logger %v."
+)
+
+// Prefixes to use for tests.
+const (
+	// TestLogPrefix is used as the initial prefix.
+	TestLogPrefix string = "LOGGING_TESTRUN"
+	// TestLogAltPrefix is used as the alternative prefix to Logger.SetPrefix.
+	TestLogAltPrefix string = "LOGGING_TESTRUN_ALT"
+)
+
+const (
+	// EnvVarKeepLog is the env var key/var name to use to suppress removal of FileLogger.Path after tests complete.
+	EnvVarKeepLog string = "LOGGING_KEEP_TEMPLOG"
+)
+
+const (
+	// logFlags are used to set the log flags for StdLogger (and FileLogger.StdLogger).
+	// logFlags int = log.Ldate | log.Lmicroseconds | log.Llongfile | log.LUTC
+	logFlags int = log.Ldate | log.Lmicroseconds | log.Lshortfile | log.LUTC
+)

logging/consts_windows.go

@@ -3,7 +3,6 @@ package logging
 import (
 	`os`
 	`path/filepath`
-	`regexp`
 
 	`r00t2.io/goutils/bitmask`
 )
@@ -28,8 +27,21 @@ var (
 	}
 )
 
-// ptrnSourceExists is a regex pattern to check for a registry entry (Event Log entry) already existing.
-var ptrnSourceExists *regexp.Regexp = regexp.MustCompile(`registry\skey\salready\sexists$`)
+/*
+	ptrnSourceExists is a regex pattern to check for a registry entry (Event Log entry) already existing.
+
+	Deprecated: this is handled differently now.
+*/
+// var ptrnSourceExists *regexp.Regexp = regexp.MustCompile(`registry\skey\salready\sexists$`)
+
+const (
+	EIDMin uint32 = 1
+	EIDMax uint32 = 1000
+)
+
+const (
+	eventLogRegistryKey string = "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application"
+)
 
 // Default WinEventID, (can be) used in GetLogger and MultiLogger.AddWinLogger.
 var DefaultEventID *WinEventID = &WinEventID{
@@ -43,7 +55,7 @@ var DefaultEventID *WinEventID = &WinEventID{
 	Warning: EventWarning,
 }
 
-// Default Event IDs for WinEventID.
+// Default Event IDs for WinEventID (DefaultEventID, specifically).
 const (
 	EventAlert uint32 = 1 << iota
 	EventCrit

logging/doc.go

@@ -35,11 +35,11 @@ Note that in the case of a MultiLogger, err (if not nil) will be a (r00t2.io/gou
 
 logging.Logger types also have the following methods:
 
-	DoDebug(d bool)
-	SetPrefix(p string)
-	GetPrefix() (p string)
-	Setup()
-	Shutdown()
+	DoDebug(d bool) (err error)
+	SetPrefix(p string) (err error)
+	GetPrefix() (p string, err error)
+	Setup() (err error)
+	Shutdown() (err error)
 
 In some cases, Logger.Setup and Logger.Shutdown are no-ops. In other cases, they perform necessary initialization/cleanup and closing of the logger.
 It is recommended to *always* run Setup and Shutdown before and after using, respectively, regardless of the actual logging.Logger type.

logging/errs_windows.go

@@ -0,0 +1,15 @@
+package logging
+
+import (
+	`errors`
+	`fmt`
+)
+
+var (
+	// ErrBadBinPath is returned if installing a binary-registered Event Log source instead of using EventCreate.exe.
+	ErrBadBinPath error = errors.New("evaluated binary path does not actually exist")
+	// ErrBadPerms is returned if an access denied error is received when attempting to register, write to, close, etc. a source without proper perms.
+	ErrBadPerms error = errors.New("access denied when attempting to register Event Log source")
+	// ErrBadEid is returned if an event ID is within an invalid range.
+	ErrBadEid error = errors.New(fmt.Sprintf("event IDs must be between %v and %v inclusive", EIDMin, EIDMax))
+)

logging/funcs.go

@@ -6,13 +6,16 @@ import (
 
 // testOpen attempts to open a file for writing to test for suitability as a LogFile path.
 func testOpen(path string) (success bool, err error) {
+
 	var f *os.File
 
 	// Example #2, https://golang.org/pkg/os/#OpenFile
 	if f, err = os.OpenFile(path, appendFlags, logPerm); err != nil {
 		return
 	}
-	defer f.Close()
+	if err = f.Close(); err != nil {
+		return
+	}
 
 	success = true
 

logging/funcs_file.go

@@ -1,61 +1,83 @@
 package logging
 
 import (
+	`errors`
 	"fmt"
-	"io"
+	`io/fs`
 	"log"
 	"os"
+	`strings`
 )
 
 // Setup sets up/configures a FileLogger and prepares it for use.
-func (l *FileLogger) Setup() {
+func (l *FileLogger) Setup() (err error) {
 
-	var err error
-	var multi io.Writer
-
-	l.Logger = log.Default()
-	l.Logger.SetPrefix(l.Prefix + " ")
+	// This uses a shared handle across the import. We don't want that.
+	// l.Logger = log.Default()
+	if l.Prefix != "" {
+		l.Prefix = strings.TrimRight(l.Prefix, " ") + " "
+		// l.Logger.SetPrefix(l.Prefix)
+	}
 	if l.writer, err = os.OpenFile(l.Path, appendFlags, logPerm); err != nil {
-		log.Panicf("could not open log file \"%v\" for writing: %v\n", l.Path, err)
+		return
 	}
-	// https://stackoverflow.com/a/36719588/733214
-	if l.EnableStdOut {
-		multi = io.MultiWriter(os.Stdout, l.writer)
-	} else {
-		multi = l.writer
-	}
-	l.Logger.SetOutput(multi)
+
+	l.Logger = log.New(l.writer, l.Prefix, l.LogFlags)
+	// l.Logger.SetOutput(multi)
+
+	return
 }
 
 // Shutdown cleanly shuts down a FileLogger.
-func (l *FileLogger) Shutdown() {
-
-	var err error
+func (l *FileLogger) Shutdown() (err error) {
 
 	if err = l.writer.Close(); err != nil {
-		log.Panicf("could not close log file \"%v\": %v\n", l.Path, err)
+		if !errors.Is(err, fs.ErrClosed) {
+			return
+		}
+		err = nil
+		return err
 	}
 
+	return
 }
 
-// GetPrefix returns the prefix used by this FileLogger.
-func (l *FileLogger) GetPrefix() string {
-	return l.Prefix
+/*
+	GetPrefix returns the prefix used by this FileLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *FileLogger) GetPrefix() (prefix string, err error) {
+
+	prefix = l.Prefix
+
+	return
 }
 
 /*
 	DoDebug sets the debug state of this FileLogger.
 	Note that this merely acts as a *safety filter* for debug messages to avoid sensitive information being written to the log.
+	err will always be nil; it's there for interface-compat.
 */
-func (l *FileLogger) DoDebug(d bool) {
+func (l *FileLogger) DoDebug(d bool) (err error) {
+
 	l.EnableDebug = d
+
+	return
 }
 
-// SetPrefix sets the prefix for this FileLogger.
-func (l *FileLogger) SetPrefix(prefix string) {
+/*
+	SetPrefix sets the prefix for this FileLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *FileLogger) SetPrefix(prefix string) (err error) {
 
-	l.Prefix = prefix + " "
-	l.Logger.SetPrefix(prefix + " ")
+	l.Prefix = prefix
+	if prefix != "" {
+		l.Prefix = strings.TrimRight(l.Prefix, " ") + " "
+	}
+	l.Logger.SetPrefix(l.Prefix)
+
+	return
 }
 
 // Alert writes an ALERT-level message to this FileLogger.

logging/funcs_linux.go

@@ -24,6 +24,9 @@ var (
 	If prefix is "\x00" (a null byte), then the default logging prefix will be used. If anything else, even an empty string,
 	is specified then that will be used instead for the prefix.
 
+	logConfigFlags is the corresponding flag(s) OR'd for StdLogger.LogFlags / FileLogger.StdLogger.LogFlags if either is selected. See StdLogger.LogFlags and
+	https://pkg.go.dev/log#pkg-constants for details.
+
 	logPaths is an (optional) list of strings to use as paths to test for writing. If the file can be created/written to,
 	it will be used (assuming you have no higher-level loggers available). Only the first logPaths entry that "works" will be used, later entries will be ignored.
 	If you want to log to multiple files simultaneously, use a MultiLogger instead.
@@ -32,10 +35,11 @@ var (
 	If you want to log to multiple Logger destinations at once (or want to log to an explicit Logger type),
 	use GetMultiLogger.
 */
-func GetLogger(enableDebug bool, prefix string, logPaths ...string) (logger Logger, err error) {
+func GetLogger(enableDebug bool, prefix string, logConfigFlags int, logPaths ...string) (logger Logger, err error) {
 
 	var logPath string
 	var logFlags bitmask.MaskBit
+	var currentPrefix string
 
 	// Configure system-supported logger(s).
 	if sysd.Enabled() {
@@ -109,6 +113,7 @@ func GetLogger(enableDebug bool, prefix string, logPaths ...string) (logger Logg
 					StdLogger: StdLogger{
 						Prefix:      logPrefix,
 						EnableDebug: enableDebug,
+						LogFlags:    logConfigFlags,
 					},
 					Path: logPath,
 				}
@@ -116,17 +121,26 @@ func GetLogger(enableDebug bool, prefix string, logPaths ...string) (logger Logg
 				logger = &StdLogger{
 					Prefix:      logPrefix,
 					EnableDebug: enableDebug,
+					LogFlags:    logConfigFlags,
 				}
 			}
 		}
 	}
 
-	logger.Setup()
 	if prefix != "\x00" {
-		logger.SetPrefix(prefix)
+		if err = logger.SetPrefix(prefix); err != nil {
+			return
+		}
+	}
+	if err = logger.Setup(); err != nil {
+		return
 	}
 
-	logger.Info("logger initialized of type %T with prefix %v", logger, logger.GetPrefix())
+	if currentPrefix, err = logger.GetPrefix(); err != nil {
+		return
+	}
+
+	logger.Debug("logger initialized of type %T with prefix %v", logger, currentPrefix)
 
 	return
 }

logging/funcs_linux_test.go

@@ -0,0 +1,270 @@
+package logging
+
+import (
+	`fmt`
+	`os`
+	`testing`
+)
+
+/*
+	TestSysDLogger tests functionality for SystemDLogger.
+*/
+func TestSysDLogger(t *testing.T) {
+
+	var l *SystemDLogger
+	var ltype string = "SystemDLogger"
+	var prefix string
+	var err error
+
+	l = &SystemDLogger{
+		EnableDebug: true,
+		Prefix:      TestLogPrefix,
+	}
+
+	if err = l.Setup(); err != nil {
+		t.Fatalf("error when running Setup: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if prefix != TestLogPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else if l.EnableDebug {
+		t.Fatalf("did not properly set Debug filter state")
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}
+
+/*
+	TestSyslogLogger tests functionality for SyslogLogger.
+*/
+func TestSyslogLogger(t *testing.T) {
+
+	var l *SyslogLogger
+	var ltype string = "SyslogLogger"
+	var prefix string
+	var err error
+
+	l = &SyslogLogger{
+		EnableDebug: true,
+		Prefix:      TestLogPrefix,
+	}
+
+	if err = l.Setup(); err != nil {
+		t.Fatalf("error when running Setup: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if prefix != TestLogPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else if l.EnableDebug {
+		t.Fatalf("did not properly set Debug filter state")
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}
+
+// TestDefaultLogger tests GetLogger.
+func TestDefaultLogger(t *testing.T) {
+
+	var l Logger
+	var tempfile *os.File
+	var tempfilePath string
+	var keepLog bool
+	var ltype string
+	var prefix string
+	var testPrefix string
+	var err error
+
+	if tempfile, err = os.CreateTemp("", ".LOGGINGTEST_*"); err != nil {
+		t.Fatalf("error when creating temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+	tempfilePath = tempfile.Name()
+	// We can close the handler immediately; we don't need it since the FileLogger opens its own.
+	if err = tempfile.Close(); err != nil {
+		t.Fatalf("error when closing handler for temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+
+	if l, err = GetLogger(true, TestLogPrefix, logFlags, tempfilePath); err != nil {
+		t.Fatalf("error when spawning default Linux logger via GetLogger: %v", err.Error())
+	}
+
+	ltype = fmt.Sprintf("%T", l)
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if ltype == "StdLogger" || ltype == "FileLogger" { // StdLogger (and thus FileLogger) adds a space at the end.
+		testPrefix = TestLogPrefix + " "
+	} else {
+		testPrefix = TestLogPrefix
+	}
+
+	if prefix != testPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	_, keepLog = os.LookupEnv(EnvVarKeepLog)
+
+	if !keepLog {
+		if err = os.Remove(tempfilePath); err != nil {
+			t.Fatalf("error when removing temporary log file '%v': %v", tempfilePath, err.Error())
+		}
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}

logging/funcs_multilogger.go

@@ -1,47 +1,80 @@
 package logging
 
 import (
+	`errors`
+	`fmt`
 	`sync`
 
 	`r00t2.io/goutils/multierr`
 )
 
 // Setup sets up/configures a MultiLogger (and all its MultiLogger.Loggers) and prepares it for use.
-func (m *MultiLogger) Setup() {
+func (m *MultiLogger) Setup() (err error) {
 
 	var wg sync.WaitGroup
+	var errs *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func() {
+		go func(logger Logger, lName string) {
+			var err2 error
 			defer wg.Done()
-			l.Setup()
-		}()
+			if err2 = logger.Setup(); err2 != nil {
+				errs.AddError(errors.New(fmt.Sprintf("error on Setup for logger %v; follows (may be out of order):", lName)))
+				errs.AddError(err2)
+				err2 = nil
+			}
+		}(l, logName)
 	}
 
 	wg.Wait()
+
+	if errs.Count() > 0 {
+		err = errs
+		return
+	}
+
+	return
 }
 
 // Shutdown cleanly shuts down a MultiLogger (and all its MultiLogger.Loggers).
-func (m *MultiLogger) Shutdown() {
+func (m *MultiLogger) Shutdown() (err error) {
 
 	var wg sync.WaitGroup
+	var errs *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func() {
+		go func(logger Logger, lName string) {
+			var err2 error
 			defer wg.Done()
-			l.Shutdown()
-		}()
+			if err2 = logger.Shutdown(); err2 != nil {
+				errs.AddError(errors.New(fmt.Sprintf("error on Shutdown for logger %v; follows (may be out of order):", lName)))
+				errs.AddError(err2)
+				err2 = nil
+			}
+		}(l, logName)
 	}
 
 	wg.Wait()
+
+	if errs.Count() > 0 {
+		err = errs
+		return
+	}
+
+	return
 }
 
-// GetPrefix returns the prefix used by this MultiLogger (and all its MultiLogger.Loggers).
-func (m *MultiLogger) GetPrefix() string {
+/*
+	GetPrefix returns the prefix used by this MultiLogger (and all its MultiLogger.Loggers).
+	err will always be nil; it's there for interface-compat.
+*/
+func (m *MultiLogger) GetPrefix() (prefix string, err error) {
 
-	return m.Prefix
+	prefix = m.Prefix
+
+	return
 
 }
 
@@ -51,21 +84,34 @@ func (m *MultiLogger) GetPrefix() string {
 
 	If you had a logger-specific EnableDebug set, you will need to re-set it to your desired state after running this method.
 */
-func (m *MultiLogger) DoDebug(d bool) {
+func (m *MultiLogger) DoDebug(d bool) (err error) {
 
 	var wg sync.WaitGroup
+	var errs *multierr.MultiError = multierr.NewMultiError(nil)
 
 	m.EnableDebug = d
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func() {
+		go func(logger Logger, lName string) {
+			var err2 error
 			defer wg.Done()
-			l.DoDebug(d)
-		}()
+			if err2 = l.DoDebug(d); err2 != nil {
+				errs.AddError(errors.New(fmt.Sprintf("error on DoDebug for logger %v; follows (may be out of order):", lName)))
+				errs.AddError(err2)
+				err2 = nil
+			}
+		}(l, logName)
 	}
 
 	wg.Wait()
+
+	if errs.Count() > 0 {
+		err = errs
+		return
+	}
+
+	return
 }
 
 /*
@@ -73,21 +119,34 @@ func (m *MultiLogger) DoDebug(d bool) {
 
 	If you had a logger-specific Prefix set, you will need to re-set it to your desired prefix after running this method.
 */
-func (m *MultiLogger) SetPrefix(prefix string) {
+func (m *MultiLogger) SetPrefix(prefix string) (err error) {
 
 	var wg sync.WaitGroup
+	var errs *multierr.MultiError = multierr.NewMultiError(nil)
 
 	m.Prefix = prefix
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func() {
+		go func(logger Logger, lName string) {
+			var err2 error
 			defer wg.Done()
-			l.SetPrefix(prefix)
-		}()
+			if err2 = l.SetPrefix(prefix); err != nil {
+				errs.AddError(errors.New(fmt.Sprintf("error on SetPrefix for logger %v; follows (may be out of order):", lName)))
+				errs.AddError(err2)
+				err2 = nil
+			}
+		}(l, logName)
 	}
 
 	wg.Wait()
+
+	if errs.Count() > 0 {
+		err = errs
+		return
+	}
+
+	return
 }
 
 // Alert writes an ALERT-level message to this MultiLogger (and all its MultiLogger.Loggers).
@@ -96,20 +155,16 @@ func (m *MultiLogger) Alert(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Alert(msg, rplc...)
-			} else {
-				err = logObj.Alert(msg)
-			}
-			if err != nil {
+			if err = logObj.Alert(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Alert for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -127,20 +182,16 @@ func (m *MultiLogger) Crit(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Crit(msg, rplc...)
-			} else {
-				err = logObj.Crit(msg)
-			}
-			if err != nil {
+			if err = logObj.Crit(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Crit for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -158,20 +209,16 @@ func (m *MultiLogger) Debug(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Debug(msg, rplc...)
-			} else {
-				err = logObj.Debug(msg)
-			}
-			if err != nil {
+			if err = logObj.Debug(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Debug for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -188,20 +235,16 @@ func (m *MultiLogger) Emerg(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Emerg(msg, rplc...)
-			} else {
-				err = logObj.Emerg(msg)
-			}
-			if err != nil {
+			if err = logObj.Emerg(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Emerg for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -218,20 +261,16 @@ func (m *MultiLogger) Err(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Err(msg, rplc...)
-			} else {
-				err = logObj.Err(msg)
-			}
-			if err != nil {
+			if err = logObj.Err(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Err for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -249,20 +288,16 @@ func (m *MultiLogger) Info(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Info(msg, rplc...)
-			} else {
-				err = logObj.Info(msg)
-			}
-			if err != nil {
+			if err = logObj.Info(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Info for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -280,20 +315,16 @@ func (m *MultiLogger) Notice(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Notice(msg, rplc...)
-			} else {
-				err = logObj.Notice(msg)
-			}
-			if err != nil {
+			if err = logObj.Notice(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Notice for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()
@@ -311,20 +342,16 @@ func (m *MultiLogger) Warning(s string, v ...interface{}) (err error) {
 	var wg sync.WaitGroup
 	var e *multierr.MultiError = multierr.NewMultiError(nil)
 
-	for _, l := range m.Loggers {
+	for logName, l := range m.Loggers {
 		wg.Add(1)
-		go func(logObj Logger, msg string, rplc ...interface{}) {
+		go func(logObj Logger, msg, lName string, rplc ...interface{}) {
 			defer wg.Done()
-			if rplc != nil {
-				err = logObj.Warning(msg, rplc...)
-			} else {
-				err = logObj.Warning(msg)
-			}
-			if err != nil {
+			if err = logObj.Warning(msg, rplc...); err != nil {
+				e.AddError(errors.New(fmt.Sprintf("error on Warning for logger %v; follows (may be out of order):", lName)))
 				e.AddError(err)
 				err = nil
 			}
-		}(l, s, v)
+		}(l, s, logName, v...)
 	}
 
 	wg.Wait()

logging/funcs_multilogger_mgr.go

@@ -21,7 +21,7 @@ func GetMultiLogger(enableDebug bool, prefix string) (m *MultiLogger) {
 
 	m = &MultiLogger{
 		EnableDebug: enableDebug,
-		Prefix:      "",
+		Prefix:      logPrefix,
 		Loggers:     make(map[string]Logger),
 	}
 	if prefix != "\x00" {
@@ -36,10 +36,19 @@ func GetMultiLogger(enableDebug bool, prefix string) (m *MultiLogger) {
 
 	identifier is a string to use to identify the added StdLogger in MultiLogger.Loggers.
 	If empty, one will be automatically generated.
+
+	enableStdOut indicates that messages should be logged to STDOUT;
+	it is *strongly encouraged* to set at least one of enableStdOut or enableStdErr to true.
+
+	enableStdErr indicates that messages should be logged to STDERR;
+	it is *strongly encouraged* to set at least one of enableStdErr or enableStdOut to true.
+
+	See GetLogger's logConfigFlags argument and StdLogger.LogFlags for details on logFlags.
 */
-func (m *MultiLogger) AddStdLogger(identifier string) (err error) {
+func (m *MultiLogger) AddStdLogger(identifier string, enableStdOut, enableStdErr bool, logFlags int) (err error) {
 
 	var exists bool
+	var prefix string
 
 	if identifier == "" {
 		identifier = uuid.New().String()
@@ -54,10 +63,19 @@ func (m *MultiLogger) AddStdLogger(identifier string) (err error) {
 		Logger:       nil,
 		EnableDebug:  m.EnableDebug,
 		Prefix:       m.Prefix,
+		LogFlags:     logFlags,
+		EnableStdOut: enableStdOut,
+		EnableStdErr: enableStdErr,
+	}
+	if err = m.Loggers[identifier].Setup(); err != nil {
+		return
 	}
-	m.Loggers[identifier].Setup()
 
-	m.Loggers[identifier].Info("logger initialized of type %T with prefix %v", m.Loggers[identifier], m.Loggers[identifier].GetPrefix())
+	if prefix, err = m.Loggers[identifier].GetPrefix(); err != nil {
+		return
+	}
+
+	m.Loggers[identifier].Debug("logger initialized of type %T with prefix %v", m.Loggers[identifier], prefix)
 
 	return
 }
@@ -70,11 +88,12 @@ func (m *MultiLogger) AddStdLogger(identifier string) (err error) {
 
 	logfilePath is a string for the path to the desired logfile.
 */
-func (m *MultiLogger) AddFileLogger(identifier, logfilePath string) (err error) {
+func (m *MultiLogger) AddFileLogger(identifier string, logFlags int, logfilePath string) (err error) {
 
 	var exists bool
 	var success bool
 	var dirPath string
+	var prefix string
 
 	if identifier == "" {
 		identifier = uuid.New().String()
@@ -85,7 +104,9 @@ func (m *MultiLogger) AddFileLogger(identifier, logfilePath string) (err error)
 		return
 	}
 
-	if exists, _ = paths.RealPathExists(&logfilePath); !exists {
+	if exists, err = paths.RealPathExists(&logfilePath); err != nil {
+		return
+	} else if !exists {
 		if success, err = testOpen(logfilePath); err != nil {
 			return
 		} else if !success {
@@ -107,12 +128,19 @@ func (m *MultiLogger) AddFileLogger(identifier, logfilePath string) (err error)
 			Logger:      nil,
 			EnableDebug: m.EnableDebug,
 			Prefix:      m.Prefix,
+			LogFlags:    logFlags,
 		},
 		Path: logfilePath,
 	}
-	m.Loggers[identifier].Setup()
+	if err = m.Loggers[identifier].Setup(); err != nil {
+		return
+	}
 
-	m.Loggers[identifier].Info("logger initialized of type %T with prefix %v", m.Loggers[identifier], m.Loggers[identifier].GetPrefix())
+	if prefix, err = m.Loggers[identifier].GetPrefix(); err != nil {
+		return
+	}
+
+	m.Loggers[identifier].Debug("logger initialized of type %T with prefix %v", m.Loggers[identifier], prefix)
 
 	return
 }

logging/funcs_multilogger_mgr_linux.go

@@ -13,8 +13,10 @@ import (
 
 	identifier is a string to use to identify the added Logger in MultiLogger.Loggers.
 	If empty, one will be automatically generated.
+
+	See the documentation for GetLogger for details on other arguments.
 */
-func (m *MultiLogger) AddDefaultLogger(identifier string, logPaths ...string) (err error) {
+func (m *MultiLogger) AddDefaultLogger(identifier string, logFlags int, logPaths ...string) (err error) {
 
 	var l Logger
 	var exists bool
@@ -28,7 +30,7 @@ func (m *MultiLogger) AddDefaultLogger(identifier string, logPaths ...string) (e
 		return
 	}
 
-	if l, err = GetLogger(m.EnableDebug, m.Prefix, logPaths...); err != nil {
+	if l, err = GetLogger(m.EnableDebug, m.Prefix, logFlags, logPaths...); err != nil {
 		return
 	}
 
@@ -46,6 +48,7 @@ func (m *MultiLogger) AddDefaultLogger(identifier string, logPaths ...string) (e
 func (m *MultiLogger) AddSysdLogger(identifier string) (err error) {
 
 	var exists bool
+	var prefix string
 
 	if identifier == "" {
 		identifier = uuid.New().String()
@@ -65,9 +68,15 @@ func (m *MultiLogger) AddSysdLogger(identifier string) (err error) {
 		EnableDebug: m.EnableDebug,
 		Prefix:      m.Prefix,
 	}
-	m.Loggers[identifier].Setup()
+	if err = m.Loggers[identifier].Setup(); err != nil {
+		return
+	}
 
-	m.Loggers[identifier].Info("logger initialized of type %T with prefix %v", m.Loggers[identifier], m.Loggers[identifier].GetPrefix())
+	if prefix, err = m.Loggers[identifier].GetPrefix(); err != nil {
+		return
+	}
+
+	m.Loggers[identifier].Debug("logger initialized of type %T with prefix %v", m.Loggers[identifier], prefix)
 
 	return
 }
@@ -84,6 +93,7 @@ func (m *MultiLogger) AddSyslogLogger(identifier string) (err error) {
 	var hasSyslog bool
 	var stat os.FileInfo
 	var devlogPath string = devlog
+	var prefix string
 
 	if identifier == "" {
 		identifier = uuid.New().String()
@@ -110,9 +120,15 @@ func (m *MultiLogger) AddSyslogLogger(identifier string) (err error) {
 		EnableDebug: m.EnableDebug,
 		Prefix:      m.Prefix,
 	}
-	m.Loggers[identifier].Setup()
+	if err = m.Loggers[identifier].Setup(); err != nil {
+		return
+	}
 
-	m.Loggers[identifier].Info("logger initialized of type %T with prefix %v", m.Loggers[identifier], m.Loggers[identifier].GetPrefix())
+	if prefix, err = m.Loggers[identifier].GetPrefix(); err != nil {
+		return
+	}
+
+	m.Loggers[identifier].Debug("logger initialized of type %T with prefix %v", m.Loggers[identifier], prefix)
 
 	return
 }

logging/funcs_multilogger_mgr_windows.go

@@ -16,10 +16,12 @@ import (
 	logPaths is an (optional) list of strings to use as paths to test for writing. If the file can be created/written to,
 	it will be used (assuming you have no higher-level loggers available).
 
+	See the documentation for GetLogger for details on other arguments.
+
 	Only the first logPaths entry that "works" will be used, later entries will be ignored.
 	Currently this will almost always return a WinLogger.
 */
-func (m *MultiLogger) AddDefaultLogger(identifier string, eventIDs *WinEventID, logPaths ...string) (err error) {
+func (m *MultiLogger) AddDefaultLogger(identifier string, eventIDs *WinEventID, logFlags int, logPaths ...string) (err error) {
 
 	var l Logger
 	var exists bool
@@ -34,9 +36,9 @@ func (m *MultiLogger) AddDefaultLogger(identifier string, eventIDs *WinEventID,
 	}
 
 	if logPaths != nil {
-		l, err = GetLogger(m.EnableDebug, m.Prefix, eventIDs, logPaths...);
+		l, err = GetLogger(m.EnableDebug, m.Prefix, eventIDs, logFlags, logPaths...)
 	} else {
-		l, err = GetLogger(m.EnableDebug, m.Prefix, eventIDs);
+		l, err = GetLogger(m.EnableDebug, m.Prefix, eventIDs, logFlags)
 	}
 	if err != nil {
 		return
@@ -63,9 +65,10 @@ func (m *MultiLogger) AddDefaultLogger(identifier string, eventIDs *WinEventID,
 
 	See GetLogger for details.
 */
-func (m *MultiLogger) AddWinLogger(identifier, source string, eventIDs *WinEventID) (err error) {
+func (m *MultiLogger) AddWinLogger(identifier string, eventIDs *WinEventID) (err error) {
 
 	var exists bool
+	var prefix string
 
 	if identifier == "" {
 		identifier = uuid.New().String()
@@ -81,13 +84,19 @@ func (m *MultiLogger) AddWinLogger(identifier, source string, eventIDs *WinEvent
 	}
 
 	m.Loggers[identifier] = &WinLogger{
-		Prefix:      source,
+		Prefix:      m.Prefix,
 		EnableDebug: m.EnableDebug,
-		eids:        eventIDs,
+		EIDs:        eventIDs,
+	}
+	if err = m.Loggers[identifier].Setup(); err != nil {
+		return
 	}
-	m.Loggers[identifier].Setup()
 
-	m.Loggers[identifier].Info("logger initialized of type %T with prefix %v", m.Loggers[identifier], m.Loggers[identifier].GetPrefix())
+	if prefix, err = m.Loggers[identifier].GetPrefix(); err != nil {
+		return
+	}
+
+	m.Loggers[identifier].Info("logger initialized of type %T with prefix %v", m.Loggers[identifier], prefix)
 
 	return
 }

logging/funcs_std.go

@@ -2,26 +2,66 @@ package logging
 
 import (
 	"fmt"
-	"log"
+	`io`
+	`log`
+	`os`
+	`strings`
 )
 
-// Setup sets up/configures a StdLogger and prepares it for use.
-func (l *StdLogger) Setup() {
+/*
+	Setup sets up/configures a StdLogger and prepares it for use.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *StdLogger) Setup() (err error) {
 
-	l.Logger = log.Default()
-	l.Logger.SetPrefix(l.Prefix + " ")
+	var multi io.Writer
+
+	// This uses a shared handle across the import. We don't want that.
+	// l.Logger = log.Default()
+	if l.Prefix != "" {
+		l.Prefix = strings.TrimRight(l.Prefix, " ") + " "
+		// l.Logger.SetPrefix(l.Prefix)
+	}
+	// (stdlib).log.std is returned by log.Default(), which uses os.Stderr but we have flags for that.
+	// https://stackoverflow.com/a/36719588/733214
+	switch {
+	case l.EnableStdErr && l.EnableStdOut:
+		multi = io.MultiWriter(os.Stdout, os.Stderr)
+	case l.EnableStdErr:
+		multi = os.Stderr
+	case l.EnableStdOut:
+		multi = os.Stdout
+	default:
+		multi = nil
+	}
+	if multi != nil {
+		l.Logger = log.New(multi, l.Prefix, l.LogFlags)
+	} else {
+		// This honestly should throw an error.
+		l.Logger = &log.Logger{}
+		l.Logger.SetPrefix(l.Prefix)
+		l.Logger.SetFlags(l.LogFlags)
+	}
+
+	return
 }
 
-// Shutdown cleanly shuts down a StdLogger.
-func (l *StdLogger) Shutdown() {
+/*
+	Shutdown cleanly shuts down a StdLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *StdLogger) Shutdown() (err error) {
 
 	// NOOP
-	_ = ""
 
+	return
 }
 
-// GetPrefix returns the prefix used by this StdLogger.
-func (l *StdLogger) GetPrefix() (prefix string) {
+/*
+	GetPrefix returns the prefix used by this StdLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *StdLogger) GetPrefix() (prefix string, err error) {
 
 	prefix = l.Prefix
 
@@ -31,15 +71,28 @@ func (l *StdLogger) GetPrefix() (prefix string) {
 /*
 	DoDebug sets the debug state of this StdLogger.
 	Note that this merely acts as a *safety filter* for debug messages to avoid sensitive information being written to the log.
+	err will always be nil; it's there for interface-compat.
 */
-func (l *StdLogger) DoDebug(d bool) {
+func (l *StdLogger) DoDebug(d bool) (err error) {
+
 	l.EnableDebug = d
+
+	return
 }
 
-// SetPrefix sets the prefix for this StdLogger.
-func (l *StdLogger) SetPrefix(prefix string) {
-	l.Prefix = prefix + " "
-	l.Logger.SetPrefix(prefix + " ")
+/*
+	SetPrefix sets the prefix for this StdLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *StdLogger) SetPrefix(prefix string) (err error) {
+
+	l.Prefix = prefix
+	if prefix != "" {
+		l.Prefix = strings.TrimRight(l.Prefix, " ") + " "
+	}
+	l.Logger.SetPrefix(l.Prefix)
+
+	return
 }
 
 // Alert writes an ALERT-level message to this StdLogger.

logging/funcs_sysd_linux.go

@@ -7,24 +7,33 @@ import (
 	"github.com/coreos/go-systemd/journal"
 )
 
-// Setup sets up/configures a SystemDLogger and prepares it for use.
-func (l *SystemDLogger) Setup() {
+/*
+	Setup sets up/configures a SystemDLogger and prepares it for use.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *SystemDLogger) Setup() (err error) {
 
 	// NOOP
-	_ = ""
 
+	return
 }
 
-// Shutdown cleanly shuts down a SystemDLogger.
-func (l *SystemDLogger) Shutdown() {
+/*
+	Shutdown cleanly shuts down a SystemDLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *SystemDLogger) Shutdown() (err error) {
 
 	// NOOP
-	_ = ""
 
+	return
 }
 
-// GetPrefix returns the prefix used by this SystemDLogger.
-func (l *SystemDLogger) GetPrefix() (prefix string) {
+/*
+	GetPrefix returns the prefix used by this SystemDLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *SystemDLogger) GetPrefix() (prefix string, err error) {
 
 	prefix = l.Prefix
 
@@ -34,14 +43,24 @@ func (l *SystemDLogger) GetPrefix() (prefix string) {
 /*
 	DoDebug sets the debug state of this SystemDLogger.
 	Note that this merely acts as a *safety filter* for debug messages to avoid sensitive information being written to the log.
+	err will always be nil; it's there for interface-compat.
 */
-func (l *SystemDLogger) DoDebug(d bool) {
+func (l *SystemDLogger) DoDebug(d bool) (err error) {
+
 	l.EnableDebug = d
+
+	return
 }
 
-// SetPrefix sets the prefix for this SystemDLogger.
-func (l *SystemDLogger) SetPrefix(prefix string) {
+/*
+	SetPrefix sets the prefix for this SystemDLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *SystemDLogger) SetPrefix(prefix string) (err error) {
+
 	l.Prefix = prefix
+
+	return
 }
 
 // Alert writes an ALERT-level message to this SystemDLogger.

logging/funcs_syslog_linux.go

@@ -4,55 +4,79 @@ import (
 	"fmt"
 	"log"
 	"log/syslog"
+
+	`r00t2.io/goutils/multierr`
 )
 
 // Setup sets up/configures a SyslogLogger and prepares it for use.
-func (l *SyslogLogger) Setup() {
+func (l *SyslogLogger) Setup() (err error) {
 
-	var err error
+	var errs *multierr.MultiError = multierr.NewMultiError(nil)
 
 	if l.alert, err = syslog.New(syslog.LOG_ALERT|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Alert")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.crit, err = syslog.New(syslog.LOG_CRIT|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Crit")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.debug, err = syslog.New(syslog.LOG_DEBUG|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Debug")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.emerg, err = syslog.New(syslog.LOG_EMERG|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Emerg")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.err, err = syslog.New(syslog.LOG_ERR|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Err")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.info, err = syslog.New(syslog.LOG_INFO|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Info")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.notice, err = syslog.New(syslog.LOG_NOTICE|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Notice")
+		errs.AddError(err)
+		err = nil
 	}
 	if l.warning, err = syslog.New(syslog.LOG_WARNING|syslogFacility, l.Prefix); err != nil {
-		log.Panicln("could not open log for Warning")
+		errs.AddError(err)
+		err = nil
 	}
 
+	if errs.Count() > 0 {
+		err = errs
+	}
+
+	return
 }
 
 // Shutdown cleanly shuts down a SyslogLogger.
-func (l *SyslogLogger) Shutdown() {
+func (l *SyslogLogger) Shutdown() (err error) {
 
-	var err error
+	var errs *multierr.MultiError = multierr.NewMultiError(nil)
 
 	for _, i := range []*syslog.Writer{l.alert, l.crit, l.debug, l.emerg, l.err, l.info, l.notice, l.warning} {
 		if err = i.Close(); err != nil {
-			log.Panicf("could not close log %#v\n", i)
+			errs.AddError(err)
+			err = nil
 		}
 	}
 
+	if errs.Count() > 0 {
+		err = errs
+	}
+
+	return
 }
 
-// GetPrefix returns the prefix used by this SyslogLogger.
-func (l *SyslogLogger) GetPrefix() (prefix string) {
+/*
+	GetPrefix returns the prefix used by this SyslogLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *SyslogLogger) GetPrefix() (prefix string, err error) {
 
 	prefix = l.Prefix
 
@@ -62,15 +86,30 @@ func (l *SyslogLogger) GetPrefix() (prefix string) {
 /*
 	DoDebug sets the debug state of this SyslogLogger.
 	Note that this merely acts as a *safety filter* for debug messages to avoid sensitive information being written to the log.
+	err will always be nil; it's there for interface-compat.
 */
-func (l *SyslogLogger) DoDebug(d bool) {
+func (l *SyslogLogger) DoDebug(d bool) (err error) {
+
 	l.EnableDebug = d
+
+	return
 }
 
 // SetPrefix sets the prefix for this SyslogLogger.
-func (l *SyslogLogger) SetPrefix(prefix string) {
+func (l *SyslogLogger) SetPrefix(prefix string) (err error) {
+
 	l.Prefix = prefix
-	l.Setup()
+
+	// We need to close the current loggers first.
+	if err = l.Shutdown(); err != nil {
+		return
+	}
+
+	if err = l.Setup(); err != nil {
+		return
+	}
+
+	return
 }
 
 // Alert writes an ALERT-level message to this SyslogLogger.

logging/funcs_test.go

@@ -0,0 +1,196 @@
+package logging
+
+import (
+	`os`
+	`testing`
+)
+
+/*
+	TestStdLogger tests functionality for StdLogger.
+*/
+func TestStdLogger(t *testing.T) {
+
+	var l *StdLogger
+	var ltype string = "StdLogger"
+	var prefix string
+	var err error
+
+	l = &StdLogger{
+		EnableDebug:  true,
+		Prefix:       TestLogPrefix,
+		LogFlags:     logFlags,
+		EnableStdOut: false,
+		EnableStdErr: true,
+	}
+
+	if err = l.Setup(); err != nil {
+		t.Fatalf("error when running Setup: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if prefix != (TestLogPrefix + " ") { // StdLogger adds a space at the end.
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else if l.EnableDebug {
+		t.Fatalf("did not properly set Debug filter state")
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}
+
+/*
+	TestFileLogger tests functionality for FileLogger.
+	If the appropriate env var is set (see the EnvVarKeepLog constant), the temporary log file that is created will not be cleaned up.
+*/
+func TestFileLogger(t *testing.T) {
+
+	var l *FileLogger
+	var ltype string = "FileLogger"
+	var prefix string
+	var tempfile *os.File
+	var tempfilePath string
+	var keepLog bool
+	var err error
+
+	if tempfile, err = os.CreateTemp("", ".LOGGINGTEST_*"); err != nil {
+		t.Fatalf("error when creating temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+	tempfilePath = tempfile.Name()
+	// We can close the handler immediately; we don't need it since the FileLogger opens its own.
+	if err = tempfile.Close(); err != nil {
+		t.Fatalf("error when closing handler for temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+
+	l = &FileLogger{
+		StdLogger: StdLogger{
+			EnableDebug: true,
+			Prefix:      TestLogPrefix,
+			LogFlags:    logFlags,
+		},
+		Path: tempfilePath,
+	}
+
+	if err = l.Setup(); err != nil {
+		t.Fatalf("error when running Setup: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if prefix != (TestLogPrefix + " ") { // StdLogger (and thus FileLogger) adds a space at the end.
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else if l.EnableDebug {
+		t.Fatalf("did not properly set Debug filter state")
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	_, keepLog = os.LookupEnv(EnvVarKeepLog)
+
+	if !keepLog {
+		if err = os.Remove(tempfilePath); err != nil {
+			t.Fatalf("error when removing temporary log file '%v': %v", tempfilePath, err.Error())
+		}
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}

logging/funcs_windows.go

@@ -22,6 +22,9 @@ import (
 	A pointer to a WinEventID struct may be specified for eventIDs to map extended logging levels (as Windows only supports three levels natively).
 	If it is nil, a default one (DefaultEventID) will be used.
 
+	logConfigFlags is the corresponding flag(s) OR'd for StdLogger.LogFlags / FileLogger.StdLogger.LogFlags if either is selected. See StdLogger.LogFlags and
+	https://pkg.go.dev/log#pkg-constants for details.
+
 	logPaths is an (optional) list of strings to use as paths to test for writing. If the file can be created/written to,
 	it will be used (assuming you have no higher-level loggers available).
 
@@ -32,13 +35,14 @@ import (
 	If you want to log to multiple Logger destinations at once (or want to log to an explicit Logger type),
 	use GetMultiLogger.
 */
-func GetLogger(enableDebug bool, source string, eventIDs *WinEventID, logPaths ...string) (logger Logger, err error) {
+func GetLogger(enableDebug bool, source string, eventIDs *WinEventID, logConfigFlags int, logPaths ...string) (logger Logger, err error) {
 
 	var logPath string
 	var logFlags bitmask.MaskBit
 	var exists bool
 	var success bool
 	var ckLogPaths []string
+	var prefix string
 
 	if strings.TrimSpace(source) == "" {
 		err = errors.New("invalid source for Windows logging")
@@ -86,7 +90,7 @@ func GetLogger(enableDebug bool, source string, eventIDs *WinEventID, logPaths .
 		logger = &WinLogger{
 			Prefix:      source,
 			EnableDebug: enableDebug,
-			eids:        eventIDs,
+			EIDs:        eventIDs,
 		}
 	} else {
 		if logFlags.HasFlag(LogFile) {
@@ -94,6 +98,7 @@ func GetLogger(enableDebug bool, source string, eventIDs *WinEventID, logPaths .
 				StdLogger: StdLogger{
 					Prefix:      source,
 					EnableDebug: enableDebug,
+					LogFlags:    logConfigFlags,
 				},
 				Path: logPath,
 			}
@@ -101,13 +106,25 @@ func GetLogger(enableDebug bool, source string, eventIDs *WinEventID, logPaths .
 			logger = &StdLogger{
 				Prefix:      source,
 				EnableDebug: enableDebug,
+				LogFlags:    logConfigFlags,
 			}
 		}
 	}
 
-	logger.Setup()
+	if err = logger.Setup(); err != nil {
+		return
+	}
+	if source != "\x00" {
+		if err = logger.SetPrefix(source); err != nil {
+			return
+		}
+	}
 
-	logger.Info("logger initialized of type %T with source %v", logger, logger.GetPrefix())
+	if prefix, err = logger.GetPrefix(); err != nil {
+		return
+	}
+
+	logger.Debug("logger initialized of type %T with source %v", logger, prefix)
 
 	return
 

logging/funcs_windows_test.go

@@ -0,0 +1,205 @@
+package logging
+
+import (
+	`fmt`
+	`os`
+	`testing`
+)
+
+/*
+	TestWinLogger tests functionality for WinLogger.
+	You will probably need to run it with an Administrator shell.
+*/
+func TestWinLogger(t *testing.T) {
+
+	var l *WinLogger
+	var ltype string = "WinLogger"
+	var prefix string
+	var exists bool
+	var err error
+
+	l = &WinLogger{
+		EnableDebug:   true,
+		Prefix:        TestLogPrefix,
+		RemoveOnClose: true,
+		EIDs:          DefaultEventID,
+	}
+
+	if exists, err = l.Exists(); err != nil {
+		t.Fatalf("error when checking for existence of registered Event Log source '%v': %v", TestLogPrefix, err.Error())
+	} else {
+		t.Logf("Prefix (source) '%v' exists before setup: %v", TestLogPrefix, exists)
+	}
+
+	if err = l.Setup(); err != nil {
+		t.Fatalf("error when running Setup: %v", err.Error())
+	}
+
+	if exists, err = l.Exists(); err != nil {
+		t.Fatalf("error when checking for existence of registered Event Log source '%v': %v", TestLogPrefix, err.Error())
+	} else {
+		t.Logf("Prefix (source) '%v' exists after setup: %v", TestLogPrefix, exists)
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if prefix != TestLogPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else if l.EnableDebug {
+		t.Fatalf("did not properly set Debug filter state")
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}
+
+// TestDefaultLogger tests GetLogger.
+func TestDefaultLogger(t *testing.T) {
+
+	var l Logger
+	var tempfile *os.File
+	var tempfilePath string
+	var keepLog bool
+	var ltype string
+	var prefix string
+	var testPrefix string
+	var err error
+
+	if tempfile, err = os.CreateTemp("", ".LOGGINGTEST_*"); err != nil {
+		t.Fatalf("error when creating temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+	tempfilePath = tempfile.Name()
+	// We can close the handler immediately; we don't need it since the FileLogger opens its own.
+	if err = tempfile.Close(); err != nil {
+		t.Fatalf("error when closing handler for temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+
+	if l, err = GetLogger(true, TestLogPrefix, DefaultEventID, logFlags, tempfilePath); err != nil {
+		t.Fatalf("error when spawning default Windows logger via GetLogger: %v", err.Error())
+	}
+
+	ltype = fmt.Sprintf("%T", l)
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if ltype == "StdLogger" || ltype == "FileLogger" { // StdLogger (and thus FileLogger) adds a space at the end.
+		testPrefix = TestLogPrefix + " "
+	} else {
+		testPrefix = TestLogPrefix
+	}
+
+	if prefix != testPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	_, keepLog = os.LookupEnv(EnvVarKeepLog)
+
+	if !keepLog {
+		if err = os.Remove(tempfilePath); err != nil {
+			t.Fatalf("error when removing temporary log file '%v': %v", tempfilePath, err.Error())
+		}
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}

logging/funcs_winlogger_windows.go

@@ -3,68 +3,135 @@ package logging
 import (
 	`errors`
 	`fmt`
+	`os`
+	`os/exec`
+	`syscall`
 
+	`golang.org/x/sys/windows/registry`
 	`golang.org/x/sys/windows/svc/eventlog`
+	`r00t2.io/sysutils/paths`
 )
 
-// Setup sets up/configures a WinLogger and prepares it for use.
-func (l *WinLogger) Setup() {
+/*
+	Setup sets up/configures a WinLogger and prepares it for use.
+	This will fail with an Access Denied (the first time, at least) unless running with elevated permissions unless WinLogger.Prefix is
+	a registered Event Log source.
 
-	var err error
+	If a failure occurs while trying to open the log with the given WinLogger.Prefix ("source"), a new Event Log source will be registered.
+	If WinLogger.Executable is not empty at the time of calling WinLogger.Setup (or WinLogger.ForceService is true),
+	eventlog.Install will be used (with the WinLogger.ExpandKey field).
+	Otherwise eventlog.InstallAsEventCreate will be used.
+*/
+func (l *WinLogger) Setup() (err error) {
 
 	/*
-		First a sanity check on the EventIDs.
+		A sanity check on the EventIDs.
 		Since we use eventcreate, all Event IDs must be 1 <= eid <= 1000.
 	*/
 	for _, eid := range []uint32{
-		l.eids.Alert,
-		l.eids.Crit,
-		l.eids.Debug,
-		l.eids.Emerg,
-		l.eids.Err,
-		l.eids.Info,
-		l.eids.Notice,
-		l.eids.Warning,
+		l.EIDs.Alert,
+		l.EIDs.Crit,
+		l.EIDs.Debug,
+		l.EIDs.Emerg,
+		l.EIDs.Err,
+		l.EIDs.Info,
+		l.EIDs.Notice,
+		l.EIDs.Warning,
 	} {
-		if !((eid <= 1000) && (1 <= eid)) {
-			err = errors.New("event IDs must be between 1 and 1000 inclusive")
-			panic(err)
+		if !((eid <= EIDMax) && (EIDMin <= eid)) {
+			err = ErrBadEid
+			return
 		}
 	}
 
-	if err = eventlog.InstallAsEventCreate(l.Prefix, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil {
-		if idx := ptrnSourceExists.FindStringIndex(err.Error()); idx == nil {
-			// It's an error we want to panic on.
-			panic(err)
-		} else {
-			// It already exists, so ignore the error.
-			err = nil
-		}
+	if err = l.Install(); err != nil {
+		return
 	}
 
 	if l.elog, err = eventlog.Open(l.Prefix); err != nil {
-		panic(err)
+		return
 	}
 
+	return
+}
+
+// Install installs/registers the WinLogger Event Log interface. You most likely do not need to run this directly.
+func (l *WinLogger) Install() (err error) {
+
+	var exists bool
+	var doNotCreate bool
+	var useEventCreate bool = true
+
+	if doNotCreate, err = l.Exists(); err != nil {
+		return
+	} else if !doNotCreate {
+		if l.Executable != "" {
+			if l.Executable, err = exec.LookPath(l.Executable); err != nil {
+				return
+			}
+			useEventCreate = false
+		} else if l.ForceService {
+			if l.Executable, err = exec.LookPath(os.Args[0]); err != nil {
+				return
+			}
+			useEventCreate = false
+		}
+		if !useEventCreate {
+			if exists, err = paths.RealPathExists(&l.Executable); err != nil {
+				return
+			} else if !exists {
+				err = ErrBadBinPath
+				return
+			}
+			if err = eventlog.Install(l.Prefix, l.Executable, l.ExpandKey, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil {
+				return
+			}
+		} else {
+			if err = eventlog.InstallAsEventCreate(l.Prefix, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil {
+				return
+			}
+		}
+	}
+
+	return
+
 }
 
-// Shutdown cleanly shuts down a WinLogger.
-func (l *WinLogger) Shutdown() {
-
-	var err error
-
-	if err = l.elog.Close(); err != nil {
-		panic(err)
-	}
+// Remove uninstalls a registered WinLogger source.
+func (l *WinLogger) Remove() (err error) {
 
 	if err = eventlog.Remove(l.Prefix); err != nil {
-		panic(err)
+		return
 	}
 
+	return
 }
 
-// GetPrefix returns the prefix used by this WinLogger.
-func (l *WinLogger) GetPrefix() (prefix string) {
+/*
+	Shutdown cleanly shuts down a WinLogger but keep the source registered. Use WinLogger.Remove
+	(or set WinLogger.RemoveOnClose to true before calling WinLogger.Shutdown) to remove the registered source.
+*/
+func (l *WinLogger) Shutdown() (err error) {
+
+	if err = l.elog.Close(); err != nil {
+		// TODO: check for no access or file not exists syscall errors?
+		return
+	}
+
+	if l.RemoveOnClose {
+		if err = l.Remove(); err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+/*
+	GetPrefix returns the prefix used by this WinLogger.
+	err will always be nil; it's there for interface-compat.
+*/
+func (l *WinLogger) GetPrefix() (prefix string, err error) {
 
 	prefix = l.Prefix
 
@@ -74,43 +141,55 @@ func (l *WinLogger) GetPrefix() (prefix string) {
 /*
 	DoDebug sets the debug state of this WinLogger.
 	Note that this merely acts as a *safety filter* for debug messages to avoid sensitive information being written to the log.
+	err will always be nil; it's there for interface-compat.
 */
-func (l *WinLogger) DoDebug(d bool) {
+func (l *WinLogger) DoDebug(d bool) (err error) {
 
 	l.EnableDebug = d
 
+	return
 }
 
 // SetPrefix sets the prefix for this WinLogger.
-func (l *WinLogger) SetPrefix(prefix string) {
+func (l *WinLogger) SetPrefix(prefix string) (err error) {
 
-	var err error
+	// To properly change the prefix, we need to tear down the old event log and create a new one.
+	if err = l.Shutdown(); err != nil {
+		return
+	}
 
 	l.Prefix = prefix
 
-	// To properly change the prefix, we need to tear down the old event log and create a new one.
-	if err = l.elog.Close(); err != nil {
-		panic(err)
+	if err = l.Setup(); err != nil {
+		return
 	}
 
-	if err = eventlog.Remove(l.Prefix); err != nil {
-		panic(err)
-	}
+	return
+}
 
-	if err = eventlog.InstallAsEventCreate(l.Prefix, eventlog.Error|eventlog.Warning|eventlog.Info); err != nil {
-		if idx := ptrnSourceExists.FindStringIndex(err.Error()); idx == nil {
-			// It's an error we want to panic on.
-			panic(err)
-		} else {
-			// It already exists, so ignore the error.
+// Exists indicates if the WinLogger.Prefix is a registered source or not.
+func (l *WinLogger) Exists() (e bool, err error) {
+
+	var regKey registry.Key
+	var subKey registry.Key
+
+	if regKey, err = registry.OpenKey(registry.LOCAL_MACHINE, eventLogRegistryKey, registry.READ); err != nil {
+		return
+	}
+	defer regKey.Close()
+
+	if subKey, err = registry.OpenKey(regKey, l.Prefix, registry.READ); err != nil {
+		if errors.Is(err, syscall.ERROR_FILE_NOT_FOUND) {
+			e = false
 			err = nil
 		}
+		return
 	}
+	defer subKey.Close()
 
-	if l.elog, err = eventlog.Open(l.Prefix); err != nil {
-		panic(err)
-	}
+	e = true
 
+	return
 }
 
 // Alert writes an ALERT-level message to this WinLogger.
@@ -125,7 +204,7 @@ func (l *WinLogger) Alert(s string, v ...interface{}) (err error) {
 	}
 
 	// Treat ALERT as Warning
-	err = l.elog.Warning(l.eids.Alert, msg)
+	err = l.elog.Warning(l.EIDs.Alert, msg)
 
 	return
 }
@@ -142,7 +221,7 @@ func (l *WinLogger) Crit(s string, v ...interface{}) (err error) {
 	}
 
 	// Treat CRIT as Error
-	err = l.elog.Error(l.eids.Crit, msg)
+	err = l.elog.Error(l.EIDs.Crit, msg)
 
 	return
 }
@@ -163,7 +242,7 @@ func (l *WinLogger) Debug(s string, v ...interface{}) (err error) {
 	}
 
 	// Treat DEBUG as Info
-	err = l.elog.Info(l.eids.Debug, msg)
+	err = l.elog.Info(l.EIDs.Debug, msg)
 
 	return
 
@@ -181,7 +260,7 @@ func (l *WinLogger) Emerg(s string, v ...interface{}) (err error) {
 	}
 
 	// Treat EMERG as Error
-	err = l.elog.Error(l.eids.Emerg, msg)
+	err = l.elog.Error(l.EIDs.Emerg, msg)
 
 	return
 
@@ -198,7 +277,7 @@ func (l *WinLogger) Err(s string, v ...interface{}) (err error) {
 		msg = s
 	}
 
-	err = l.elog.Error(l.eids.Err, msg)
+	err = l.elog.Error(l.EIDs.Err, msg)
 
 	return
 
@@ -215,7 +294,7 @@ func (l *WinLogger) Info(s string, v ...interface{}) (err error) {
 		msg = s
 	}
 
-	err = l.elog.Info(l.eids.Info, msg)
+	err = l.elog.Info(l.EIDs.Info, msg)
 
 	return
 
@@ -233,7 +312,7 @@ func (l *WinLogger) Notice(s string, v ...interface{}) (err error) {
 	}
 
 	// Treat NOTICE as Info
-	err = l.elog.Info(l.eids.Notice, msg)
+	err = l.elog.Info(l.EIDs.Notice, msg)
 
 	return
 
@@ -250,7 +329,7 @@ func (l *WinLogger) Warning(s string, v ...interface{}) (err error) {
 		msg = s
 	}
 
-	err = l.elog.Warning(l.eids.Warning, msg)
+	err = l.elog.Warning(l.EIDs.Warning, msg)
 
 	return
 

logging/muiltilogger_linux_test.go

@@ -0,0 +1,121 @@
+package logging
+
+import (
+	`os`
+	`testing`
+)
+
+// TestMultiLogger tests GetMultiLogger and MultiLogger methods.
+func TestMultiLogger(t *testing.T) {
+
+	var l *MultiLogger
+	var tempfile *os.File
+	var tempfilePath string
+	var keepLog bool
+	var ltype string = "MultiLogger"
+	var prefix string
+	var testPrefix string
+	var err error
+
+	if tempfile, err = os.CreateTemp("", ".LOGGINGTEST_*"); err != nil {
+		t.Fatalf("error when creating temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+	tempfilePath = tempfile.Name()
+	// We can close the handler immediately; we don't need it since the FileLogger opens its own.
+	if err = tempfile.Close(); err != nil {
+		t.Fatalf("error when closing handler for temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+
+	l = GetMultiLogger(true, TestLogPrefix)
+
+	if err = l.AddStdLogger("StdLogger", false, true, logFlags); err != nil {
+		t.Fatalf("error when adding StdLogger to MultiLogger: %v", err.Error())
+	}
+	if err = l.AddFileLogger("FileLogger", logFlags, tempfilePath); err != nil {
+		t.Fatalf("error when adding FileLogger to MultiLogger: %v", err.Error())
+	}
+
+	if err = l.AddDefaultLogger("DefaultLogger", logFlags, tempfilePath); err != nil {
+		t.Fatalf("error when adding default logger to MultiLogger: %v", err.Error())
+	}
+
+	if err = l.AddSysdLogger("SystemDLogger"); err != nil {
+		t.Fatalf("error when adding SystemDLogger to MultiLogger: %v", err.Error())
+	}
+	if err = l.AddSyslogLogger("SyslogLogger"); err != nil {
+		t.Fatalf("error when adding SyslogLogger to MultiLogger: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if ltype == "StdLogger" || ltype == "FileLogger" { // StdLogger (and thus FileLogger) adds a space at the end.
+		testPrefix = TestLogPrefix + " "
+	} else {
+		testPrefix = TestLogPrefix
+	}
+
+	if prefix != testPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	_, keepLog = os.LookupEnv(EnvVarKeepLog)
+
+	if !keepLog {
+		if err = os.Remove(tempfilePath); err != nil {
+			t.Fatalf("error when removing temporary log file '%v': %v", tempfilePath, err.Error())
+		}
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}

logging/multilogger_windows_test.go

@@ -0,0 +1,118 @@
+package logging
+
+import (
+	`os`
+	`testing`
+)
+
+// TestMultiLogger tests GetMultiLogger and MultiLogger methods.
+func TestMultiLogger(t *testing.T) {
+
+	var l *MultiLogger
+	var tempfile *os.File
+	var tempfilePath string
+	var keepLog bool
+	var ltype string = "MultiLogger"
+	var prefix string
+	var testPrefix string
+	var err error
+
+	if tempfile, err = os.CreateTemp("", ".LOGGINGTEST_*"); err != nil {
+		t.Fatalf("error when creating temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+	tempfilePath = tempfile.Name()
+	// We can close the handler immediately; we don't need it since the FileLogger opens its own.
+	if err = tempfile.Close(); err != nil {
+		t.Fatalf("error when closing handler for temporary log file '%v': %v", tempfile.Name(), err.Error())
+	}
+
+	l = GetMultiLogger(true, TestLogPrefix)
+
+	if err = l.AddStdLogger("StdLogger", false, true, logFlags); err != nil {
+		t.Fatalf("error when adding StdLogger to MultiLogger: %v", err.Error())
+	}
+	if err = l.AddFileLogger("FileLogger", logFlags, tempfilePath); err != nil {
+		t.Fatalf("error when adding FileLogger to MultiLogger: %v", err.Error())
+	}
+
+	if err = l.AddDefaultLogger("DefaultLogger", DefaultEventID, logFlags, tempfilePath); err != nil {
+		t.Fatalf("error when adding default logger to MultiLogger: %v", err.Error())
+	}
+
+	if err = l.AddWinLogger("WinLogger", DefaultEventID); err != nil {
+		t.Fatalf("error when adding WinLogger to MultiLogger: %v", err.Error())
+	}
+
+	t.Logf("Logger %v passed Setup. Logger: %#v", ltype, l)
+
+	if err = l.Alert(testAlert, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Crit(testCrit, ltype); err != nil {
+		t.Fatalf("error for Crit: %v", err.Error())
+	}
+
+	if err = l.Debug(testDebug, ltype); err != nil {
+		t.Fatalf("error for Debug: %v", err.Error())
+	}
+
+	if err = l.Emerg(testEmerg, ltype); err != nil {
+		t.Fatalf("error for Emerg: %v", err.Error())
+	}
+
+	if err = l.Err(testErr, ltype); err != nil {
+		t.Fatalf("error for Err: %v", err.Error())
+	}
+
+	if err = l.Info(testInfo, ltype); err != nil {
+		t.Fatalf("error for Alert: %v", err.Error())
+	}
+
+	if err = l.Notice(testNotice, ltype); err != nil {
+		t.Fatalf("error for Notice: %v", err.Error())
+	}
+
+	if err = l.Warning(testWarning, ltype); err != nil {
+		t.Fatalf("error for Warning: %v", err.Error())
+	}
+
+	if prefix, err = l.GetPrefix(); err != nil {
+		t.Fatalf("error when fetching prefix: %v", err.Error())
+	}
+
+	if ltype == "StdLogger" || ltype == "FileLogger" { // StdLogger (and thus FileLogger) adds a space at the end.
+		testPrefix = TestLogPrefix + " "
+	} else {
+		testPrefix = TestLogPrefix
+	}
+
+	if prefix != testPrefix {
+		t.Fatalf("true prefix ('%v') does not match TestLogPrefix ('%v')", prefix, TestLogPrefix)
+	}
+	if err = l.SetPrefix(TestLogAltPrefix); err != nil {
+		t.Fatalf("error when setting prefix to %v: %v", TestLogAltPrefix, err.Error())
+	} else {
+		_ = l.SetPrefix(TestLogPrefix)
+	}
+
+	if err = l.DoDebug(false); err != nil {
+		t.Fatalf("error when changing debug to false: %v", err.Error())
+	} else {
+		_ = l.DoDebug(true)
+	}
+
+	if err = l.Shutdown(); err != nil {
+		t.Fatalf("Error when running Shutdown: %v", err.Error())
+	}
+
+	_, keepLog = os.LookupEnv(EnvVarKeepLog)
+
+	if !keepLog {
+		if err = os.Remove(tempfilePath); err != nil {
+			t.Fatalf("error when removing temporary log file '%v': %v", tempfilePath, err.Error())
+		}
+	}
+
+	t.Logf("Logger %v passed all logging targets.", ltype)
+}

logging/types.go

@@ -17,11 +17,11 @@ type Logger interface {
 	Info(s string, v ...interface{}) (err error)
 	Notice(s string, v ...interface{}) (err error)
 	Warning(s string, v ...interface{}) (err error)
-	DoDebug(d bool)
-	SetPrefix(p string)
-	GetPrefix() (p string)
-	Setup()
-	Shutdown()
+	DoDebug(d bool) (err error)
+	SetPrefix(p string) (err error)
+	GetPrefix() (p string, err error)
+	Setup() (err error)
+	Shutdown() (err error)
 }
 
 /*
@@ -38,20 +38,50 @@ type StdLogger struct {
 	EnableDebug bool
 	// Prefix indicates the prefix for log entries; in shared logs, this helps differentiate the source.
 	Prefix string
+	/*
+		LogFlags control some of the formatting options presented as an OR'd value.
+		See https://pkg.go.dev/log#pkg-constants for flag details.
+		e.g.:
+			*StdLogger.LogFlags = log.Ldate | log.Lmicroseconds | log.Llongfile | log.LUTC // a very detailed log output
+			*StdLogger.LogFlags = log.Ldate | log.Ltime // the flags used by log.Default() (also available as simply log.LstdFlags)
+		The default is 0; no flags (no output except prefix if non-empty and message).
+		You will need to run *StdLogger.Shutdown and then *StdLogger.Setup again if you wish to change this.
+	*/
+	LogFlags int
+	/*
+		EnableStdOut is true if the log will send to STDOUT.
+		If false (default), no output will be written to STDOUT.
+		You will need to run StdLogger.Shutdown and then StdLogger.Setup again if you wish to change this.
+
+		If EnableStdOut is false and EnableStdErr is false, no logging output will occur by default
+		and StdLogger.Logger will be largely useless.
+		It will be up to you to modify the underlying log.Logger to behave as you want.
+	*/
+	EnableStdOut bool
+	/*
+		EnableStdErr is true if the log will send to STDERR.
+		If false (default), no output will be written to STDERR.
+		You will need to run StdLogger.Shutdown and then StdLogger.Setup again if you wish to change this.
+
+		If EnableStdErr is false and EnableStdOut is false, no logging output will occur by default
+		and StdLogger.Logger will be largely useless.
+		It will be up to you to modify the underlying log.Logger to behave as you want.
+	*/
+	EnableStdErr bool
 }
 
-// FileLogger uses a StdLogger with a file handle writer to write to the file given at Path.
+/*
+	FileLogger uses a StdLogger with a file handle writer to write to the file given at Path.
+
+	NOTE: If you wish to change the FileLogger.StdLogger.LogFlags, do *not* run FileLogger.StdLogger.Setup after doing so as this
+	will instead create a logger detached from the file handler. Instead, be sure to call FileLogger.Setup.
+	(Alternatively, run FileLogger.Shutdown and replace your logger with a new FileLogger.)
+*/
 type FileLogger struct {
 	// StdLogger is used for the log formation and handling. See StdLogger for more details.
 	StdLogger
 	// Path is the path to the logfile.
 	Path string
-	/*
-		EnableStdOut is true if the log will send to STDOUT as well as the file.
-		If false (default), it will only (silently) write to the log file.
-		You will need to run *FileLogger.Shutdown and then *FileLogger.Setup again if you wish to change this.
-	*/
-	EnableStdOut bool
 	// writer is used for the writing out of the log file.
 	writer *os.File
 }

logging/types_linux.go

@@ -4,11 +4,15 @@ import (
 	`log/syslog`
 )
 
+/*
+	SystemDLogger (yes, I'm aware it's actually written as "systemd") writes to journald on systemd-enabled systems.
+*/
 type SystemDLogger struct {
 	EnableDebug bool
 	Prefix      string
 }
 
+// SyslogLogger writes to syslog on syslog-enabled systems.
 type SyslogLogger struct {
 	EnableDebug bool
 	Prefix      string

logging/types_windows.go

@@ -4,13 +4,60 @@ import (
 	`golang.org/x/sys/windows/svc/eventlog`
 )
 
+// WinLogger is used for logging to the Windows Event Log. These entries are viewable in the Event Viewer application, under "Windows Logs > Application".
 type WinLogger struct {
+	/*
+		EnableDebug indicates if the debug filter should be disabled (true) or if the filter should be enabled (false).
+		This prevents potential data leak of sensitive information, as some loggers (e.g. FileLogger) will otherwise write all messages.
+	*/
 	EnableDebug bool
+	/*
+		Prefix is used as the Event Log "Source". It's named as Prefix to retain compatability with methods in the Logger interface.
+	*/
 	Prefix string
+	/*
+		Executable is used as the path for the executable implementing this logger.
+		If non-empty, it enables the "service" mode of Event Log (intended for "installed" software that's expected
+		to exist as a specific path reliably).
+		It can be a file within the PATHs or an absolute/relative path; an attempt to resolve the actual path will be made. If this fails or the file
+		does not exist, an error will be raised.
+	*/
+	Executable string
+	/*
+		ExpandKey is only used if Executable is non-empty and valid and/or ForceService is true.
+		If true, the WinLogger will be installed/registered with the REG_EXPAND_SZ mode - otherwise it will be installed as REG_SZ.
+		See the definition for the two at https://docs.microsoft.com/en-us/windows/win32/sysinfo/registry-value-types for further details.
+		If you're unsure which you want, it's probably REG_SZ (WinLogger.ExpandKey == false), which is the default.
+	*/
+	ExpandKey bool
+	/*
+		ForceService, if true, will enforce WinLogger to be used as if Executable is populated and valid (it will use os.Args[0] as the Executable path).
+		If Executable is empty but ForceService is true and os.Args[0] is empty or invalid (not a real path, etc.), an error will be raised.
+	*/
+	ForceService bool
+	// RemoveOnClose should be true if the logger should be removed/unregistered from the Registry upon calling WinLogger.Shutdown.
+	RemoveOnClose bool
+	// elog is the actual writer to the Event Log.
 	elog *eventlog.Log
-	eids        *WinEventID
+	// EIDs is used to look up what event ID to use when writing to a WinLogger.elog.
+	EIDs *WinEventID
 }
 
+/*
+	WinEventID is a collection of Event IDs to use for a WinLogger.
+	Because Event Log only supports three entry types (informational, warning, or error),
+	these event IDs allow you to filter the messages in a slightly more granular way. They map to their corresponding method name/Logger level.
+	However, this means that a WinLogger does not support custom event IDs (and thus you cannot assign individual event IDs to specific errors).
+	This is the price of convenience.
+
+	An additional method set may be added in the future to support this, but this is currently an unplanned feature.
+
+	Event IDs *must* be between the constants EIDMin and EIDMax (inclusive) unless the WinLogger is used in "service" mode
+	(see WinLogger.Executable and WinLogger.ForceService).
+
+	If you need recommended defaults, you may want to use the Event* constants (e.g. EventAlert, EventDebug, etc.)
+	or even use the pre-populated DefaultEventID (which is assigned the above Event* constants).
+*/
 type WinEventID struct {
 	Alert,
 	Crit,