consolidate logging, fixes by nallux

broadcast/broadcast.go

@@ -9,7 +9,6 @@ import (
 	"goseg/startram"
 	"goseg/structs"
 	"goseg/system"
-	"log/slog"
 	"math"
 	"os"
 	"reflect"
@@ -21,7 +20,6 @@ import (
 )
 
 var (
-	logger           = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	clients          = make(map[*websocket.Conn]bool)
 	hostInfoInterval = 3 * time.Second // how often we refresh system info
 	shipInfoInterval = 3 * time.Second // how often we refresh ship info
@@ -32,8 +30,8 @@ var (
 
 func init() {
 	// initialize broadcastState global var
-	config := config.Conf()
-	broadcast, err := bootstrapBroadcastState(config)
+	conf := config.Conf()
+	broadcast, err := bootstrapBroadcastState(conf)
 	if err != nil {
 		errmsg := fmt.Sprintf("Unable to initialize broadcast: %v", err)
 		panic(errmsg)
@@ -61,13 +59,13 @@ func UnregisterClient(conn *websocket.Conn) {
 }
 
 // take in config file and addt'l info to initialize broadcast
-func bootstrapBroadcastState(config structs.SysConfig) (structs.AuthBroadcast, error) {
-	logger.Info("Bootstrapping state")
+func bootstrapBroadcastState(conf structs.SysConfig) (structs.AuthBroadcast, error) {
+	config.Logger.Info("Bootstrapping state")
 	var res structs.AuthBroadcast
 	// get a list of piers from config
-	piers := config.Piers
+	piers := conf.Piers
 	// this returns a map of ship:running status
-	logger.Info("Resolving pier status")
+	config.Logger.Info("Resolving pier status")
 	updates, err := constructPierInfo(piers)
 	if err != nil {
 		return res, err
@@ -78,16 +76,16 @@ func bootstrapBroadcastState(config structs.SysConfig) (structs.AuthBroadcast, e
 	})
 	if err != nil {
 		errmsg := fmt.Sprintf("Unable to update broadcast state: %v", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return res, err
 	}
 	// wgRegistered := config.WgRegistered
 	// wgOn := config.WgOn
 	// get startram regions
-	logger.Info("Retrieving StarTram region info")
+	config.Logger.Info("Retrieving StarTram region info")
 	regions, err := startram.GetRegions()
 	if err != nil {
-		logger.Warn("Couldn't get StarTram regions")
+		config.Logger.Warn("Couldn't get StarTram regions")
 	} else {
 		updates := map[string]interface{}{
 			"Profile": map[string]interface{}{
@@ -101,7 +99,7 @@ func bootstrapBroadcastState(config structs.SysConfig) (structs.AuthBroadcast, e
 		err := UpdateBroadcastState(updates)
 		if err != nil {
 			errmsg := fmt.Sprintf("Error updating broadcast state:", err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 		}
 	}
 	// update with system state
@@ -109,7 +107,7 @@ func bootstrapBroadcastState(config structs.SysConfig) (structs.AuthBroadcast, e
 	err = UpdateBroadcastState(sysInfo)
 	if err != nil {
 		errmsg := fmt.Sprintf("Error updating broadcast state:", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 	}
 	// start looping info refreshes
 	go hostStatusLoop()
@@ -130,13 +128,13 @@ func constructPierInfo(piers []string) (map[string]structs.Urbit, error) {
 	pierStatus, err := docker.GetShipStatus(piers)
 	if err != nil {
 		errmsg := fmt.Sprintf("Unable to bootstrap urbit states: %v", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return updates, err
 	}
 	hostName, err := os.Hostname()
 	if err != nil {
 		errmsg := fmt.Sprintf("Error getting hostname, defaulting to `nativeplanet`: %v", err)
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		hostName = "nativeplanet"
 	}
 	// convert the running status into bools
@@ -145,7 +143,7 @@ func constructPierInfo(piers []string) (map[string]structs.Urbit, error) {
 		err := config.LoadUrbitConfig(pier)
 		if err != nil {
 			errmsg := fmt.Sprintf("Unable to load %s config: %v", pier, err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 			continue
 		}
 		dockerConfig := config.UrbitConf(pier)
@@ -154,7 +152,7 @@ func constructPierInfo(piers []string) (map[string]structs.Urbit, error) {
 		dockerStats, err = docker.GetContainerStats(pier)
 		if err != nil {
 			errmsg := fmt.Sprintf("Unable to load %s stats: %v", pier, err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 			continue
 		}
 		urbit := structs.Urbit{}
@@ -222,7 +220,7 @@ func GetContainerNetworks(containers []string) map[string]string {
 		network, err := docker.GetContainerNetwork(container)
 		if err != nil {
 			errmsg := fmt.Sprintf("Error getting container network: %v", err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 			continue
 		} else {
 			res[container] = network
@@ -320,13 +318,11 @@ func GetState() structs.AuthBroadcast {
 
 // return json string of current broadcast state
 func GetStateJson() ([]byte, error) {
-	mu.Lock()
-	defer mu.Unlock()
 	bState := GetState()
 	broadcastJson, err := json.Marshal(bState)
 	if err != nil {
 		errmsg := fmt.Sprintf("Error marshalling response: %v", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return nil, err
 	}
 	return broadcastJson, nil
@@ -343,7 +339,7 @@ func BroadcastToClients() error {
 	defer auth.AuthenticatedClients.Unlock()
 	for client := range auth.AuthenticatedClients.Conns {
 		if err := client.WriteMessage(websocket.TextMessage, authJson); err != nil {
-			logger.Error(fmt.Sprintf("Error writing response: %v", err))
+			config.Logger.Error(fmt.Sprintf("Error writing response: %v", err))
 			return err
 		}
 	}
@@ -359,7 +355,7 @@ func hostStatusLoop() {
 			update := constructSystemInfo()
 			err := UpdateBroadcastState(update)
 			if err != nil {
-				logger.Warn(fmt.Sprintf("Error updating system status: %v", err))
+				config.Logger.Warn(fmt.Sprintf("Error updating system status: %v", err))
 			}
 		}
 	}
@@ -371,9 +367,12 @@ func shipStatusLoop() {
 	for {
 		select {
 		case <-ticker.C:
+			conf := config.Conf()
+			piers := conf.Piers
 			updates, err := constructPierInfo(piers)
 			if err != nil {
-				return res, err
+				errmsg := fmt.Sprintf("Unable to build pier info: %v",err)
+				config.Logger.Warn(errmsg)
 			}
 			// update broadcastState
 			err = UpdateBroadcastState(map[string]interface{}{
@@ -381,8 +380,7 @@ func shipStatusLoop() {
 			})
 			if err != nil {
 				errmsg := fmt.Sprintf("Unable to update ship state: %v", err)
-				logger.Error(errmsg)
-				return res, err
+				config.Logger.Error(errmsg)
 			}
 		}
 	}

config/config.go

@@ -20,7 +20,7 @@ import (
 )
 
 var (
-	logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
+	Logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	// global settings config (accessed via funcs)
 	globalConfig structs.SysConfig
 	// base path for installation (override default with env var)
@@ -45,12 +45,12 @@ var (
 
 // try initializing from system.json on disk
 func init() {
-	logger.Info("Starting GroundSeg")
-	logger.Info("Urbit is love <3")
+	Logger.Info("Starting GroundSeg")
+	Logger.Info("Urbit is love <3")
 	for _, arg := range os.Args[1:] {
 		// trigger this with `./groundseg dev`
 		if arg == "dev" {
-			logger.Info("Starting GroundSeg in debug mode")
+			Logger.Info("Starting GroundSeg in debug mode")
 			DebugMode = true
 		}
 	}
@@ -59,7 +59,7 @@ func init() {
 		BasePath = "/opt/nativeplanet/groundseg"
 	}
 	pathMsg := fmt.Sprintf("Loading configs from %s", BasePath)
-	logger.Info(pathMsg)
+	Logger.Info(pathMsg)
 	confPath := filepath.Join(BasePath, "settings", "system.json")
 	file, err := os.Open(confPath)
 	if err != nil {
@@ -68,14 +68,14 @@ func init() {
 		if err != nil {
 			// panic if we can't create it
 			errmsg := fmt.Sprintf("Unable to create config! Please elevate permissions. %v", err)
-			logger.Error(errmsg)
+			Logger.Error(errmsg)
 			panic(errmsg)
 		}
 		// generate and insert wireguard keys
 		wgPriv, wgPub, err := WgKeyGen()
 		salt := RandString(32)
 		if err != nil {
-			logger.Error(fmt.Sprintf("%v", err))
+			Logger.Error(fmt.Sprintf("%v", err))
 		} else {
 			err = UpdateConf(map[string]interface{}{
 				"Pubkey":  wgPub,
@@ -83,7 +83,7 @@ func init() {
 				"Salt":    salt,
 			})
 			if err != nil {
-				logger.Error(fmt.Sprintf("%v", err))
+				Logger.Error(fmt.Sprintf("%v", err))
 			}
 		}
 	}
@@ -93,7 +93,7 @@ func init() {
 	err = decoder.Decode(&globalConfig)
 	if err != nil {
 		errmsg := fmt.Sprintf("Error decoding JSON: %v", err)
-		logger.Error(errmsg)
+		Logger.Error(errmsg)
 	}
 }
 
@@ -196,7 +196,7 @@ func UpdateContainerState(name string, containerState structs.ContainerState) {
 	defer contMutex.Unlock()
 	GSContainers[name] = containerState
 	res, _ := json.Marshal(containerState)
-	logger.Info(fmt.Sprintf("%s:%s", name, string(res)))
+	Logger.Info(fmt.Sprintf("%s:%s", name, string(res)))
 }
 
 // get the current container state
@@ -234,7 +234,7 @@ func NetCheck(netCheck string) bool {
 	conn, err := net.DialTimeout("tcp", netCheck, timeout)
 	if err != nil {
 		errmsg := fmt.Sprintf("Check internet access error: %v", err)
-		logger.Error(errmsg)
+		Logger.Error(errmsg)
 	} else {
 		internet = true
 		_ = conn.Close()
@@ -247,7 +247,7 @@ func RandString(length int) string {
 	randBytes := make([]byte, length)
 	_, err := rand.Read(randBytes)
 	if err != nil {
-		logger.Warn("Random error :s")
+		Logger.Warn("Random error :s")
 		return ""
 	}
 	return base64.URLEncoding.EncodeToString(randBytes)

config/version.go

@@ -31,7 +31,7 @@ func CheckVersion() (structs.Channel, bool) {
 		resp, err := http.Get(url)
 		if err != nil {
 			errmsg := fmt.Sprintf("Unable to connect to update server: %v", err)
-			logger.Warn(errmsg)
+			Logger.Warn(errmsg)
 			if i < retries-1 {
 				time.Sleep(delay)
 				continue
@@ -45,7 +45,7 @@ func CheckVersion() (structs.Channel, bool) {
 		resp.Body.Close()
 		if err != nil {
 			errmsg := fmt.Sprintf("Error reading version info: %v", err)
-			logger.Warn(errmsg)
+			Logger.Warn(errmsg)
 			if i < retries-1 {
 				time.Sleep(delay)
 				continue
@@ -58,7 +58,7 @@ func CheckVersion() (structs.Channel, bool) {
 		err = json.Unmarshal(body, &fetchedVersion)
 		if err != nil {
 			errmsg := fmt.Sprintf("Error unmarshalling JSON: %v", err)
-			logger.Warn(errmsg)
+			Logger.Warn(errmsg)
 			if i < retries-1 {
 				time.Sleep(delay)
 				continue
@@ -73,7 +73,7 @@ func CheckVersion() (structs.Channel, bool) {
 		file, err := os.Create(confPath)
 		if err != nil {
 			errmsg := fmt.Sprintf("Failed to create file: %v", err)
-			logger.Error(errmsg)
+			Logger.Error(errmsg)
 			VersionServerReady = false
 			return VersionInfo, false
 		}
@@ -82,7 +82,7 @@ func CheckVersion() (structs.Channel, bool) {
 		encoder.SetIndent("", "    ")
 		if err := encoder.Encode(&fetchedVersion); err != nil {
 			errmsg := fmt.Sprintf("Failed to write JSON: %v", err)
-			logger.Error(errmsg)
+			Logger.Error(errmsg)
 		}
 		VersionServerReady = true
 		return VersionInfo, true
@@ -139,7 +139,7 @@ func LocalVersion() structs.Version {
 		if err != nil {
 			// panic if we can't create it
 			errmsg := fmt.Sprintf("Unable to write version info! %v", err)
-			logger.Error(errmsg)
+			Logger.Error(errmsg)
 			panic(errmsg)
 		}
 	}

docker/docker.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"goseg/config"
 	"goseg/structs"
-	"log/slog"
-	"os"
 	"strings"
 	"time"
 
@@ -17,7 +15,6 @@ import (
 )
 
 var (
-	logger   = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	EventBus = make(chan structs.Event, 100)
 )
 
@@ -27,13 +24,13 @@ func GetShipStatus(patps []string) (map[string]string, error) {
 	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
 	if err != nil {
 		errmsg := fmt.Sprintf("Error getting Docker info: %v", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return statuses, err
 	} else {
-		containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
+		containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true})
 		if err != nil {
 			errmsg := fmt.Sprintf("Error getting containers: %v", err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 			return statuses, err
 		} else {
 			for _, pier := range patps {
@@ -214,7 +211,7 @@ func StartContainer(containerName string, containerType string) (structs.Contain
 			return containerState, err
 		}
 		msg := fmt.Sprintf("%s started with image %s", containerName, desiredImage)
-		logger.Info(msg)
+		config.Logger.Info(msg)
 	case existingContainer.State == "exited":
 		// if the container exists but is stopped, start it
 		err := cli.ContainerStart(ctx, containerName, types.ContainerStartOptions{})
@@ -222,7 +219,7 @@ func StartContainer(containerName string, containerType string) (structs.Contain
 			return containerState, err
 		}
 		msg := fmt.Sprintf("Started stopped container %s", containerName)
-		logger.Info(msg)
+		config.Logger.Info(msg)
 	default:
 		// if container is running, check the image digest
 		currentImage := existingContainer.Image
@@ -248,7 +245,7 @@ func StartContainer(containerName string, containerType string) (structs.Contain
 				return containerState, err
 			}
 			msg := fmt.Sprintf("Restarted %s with image %s", containerName, desiredImage)
-			logger.Info(msg)
+			config.Logger.Info(msg)
 		}
 	}
 	containerDetails, err := cli.ContainerInspect(ctx, containerName)
@@ -330,7 +327,7 @@ func StopContainerByName(containerName string) error {
 				if err := cli.ContainerStop(ctx, cont.ID, options); err != nil {
 					return fmt.Errorf("failed to stop container %s: %v", containerName, err)
 				}
-				logger.Info(fmt.Sprintf("Successfully stopped container %s\n", containerName))
+				config.Logger.Info(fmt.Sprintf("Successfully stopped container %s\n", containerName))
 				return nil
 			}
 		}
@@ -343,7 +340,7 @@ func DockerListener() {
 	ctx := context.Background()
 	cli, err := client.NewClientWithOpts(client.FromEnv)
 	if err != nil {
-		logger.Error(fmt.Sprintf("Error initializing Docker client: %v", err))
+		config.Logger.Error(fmt.Sprintf("Error initializing Docker client: %v", err))
 		return
 	}
 	messages, errs := cli.Events(ctx, types.EventsOptions{})
@@ -353,7 +350,7 @@ func DockerListener() {
 			// Convert the Docker event to our custom event and send it to the EventBus
 			EventBus <- structs.Event{Type: event.Action, Data: event}
 		case err := <-errs:
-			logger.Error(fmt.Sprintf("Docker event error: %v", err))
+			config.Logger.Error(fmt.Sprintf("Docker event error: %v", err))
 		}
 	}
 }
@@ -364,7 +361,7 @@ func DockerPoller() {
 	for {
 		select {
 		case <-ticker.C:
-			logger.Info("polling docker")
+			config.Logger.Info("polling docker")
 			// todo (maybe not necessary?)
 			// fetch the status of all containers and compare with app's state
 			// if there's a change, send an event to the EventBus

docker/minio.go

@@ -11,7 +11,7 @@ import (
 )
 
 func LoadMC() error {
-	logger.Info("Loading MC container")
+	config.Logger.Info("Loading MC container")
 	confPath := filepath.Join(config.BasePath, "settings", "mc.json")
 	_, err := os.Open(confPath)
 	if err != nil {
@@ -20,13 +20,13 @@ func LoadMC() error {
 		if err != nil {
 			// error if we can't create it
 			errmsg := fmt.Sprintf("Unable to create MC config! %v", err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 		}
 	}
-	logger.Info("Running MC")
+	config.Logger.Info("Running MC")
 	info, err := StartContainer("mc", "miniomc")
 	if err != nil {
-		logger.Error(fmt.Sprintf("Error starting MC: %v", err))
+		config.Logger.Error(fmt.Sprintf("Error starting MC: %v", err))
 		return err
 	}
 	config.UpdateContainerState("mc", info)
@@ -36,14 +36,14 @@ func LoadMC() error {
 // iterate through each ship and create a minio
 // version stuff is offloaded to version server struct
 func LoadMinIOs() error {
-	logger.Info("Loading MinIO containers")
+	config.Logger.Info("Loading MinIO containers")
 	conf := config.Conf()
 	for _, pier := range conf.Piers {
 		// uConf := config.UrbitConf(pier)
 		label := "minio_" + pier
 		info, err := StartContainer(label, "minio")
 		if err != nil {
-			logger.Error(fmt.Sprintf("Error starting %s Minio: %v", pier, err))
+			config.Logger.Error(fmt.Sprintf("Error starting %s Minio: %v", pier, err))
 			return err
 		}
 		config.UpdateContainerState(label, info)

docker/netdata.go

@@ -10,7 +10,7 @@ import (
 )
 
 func LoadNetdata() error {
-	logger.Info("Loading NetData container")
+	config.Logger.Info("Loading NetData container")
 	confPath := filepath.Join(config.BasePath, "settings", "netdata.json")
 	_, err := os.Open(confPath)
 	if err != nil {
@@ -19,14 +19,14 @@ func LoadNetdata() error {
 		if err != nil {
 			// panic if we can't create it
 			errmsg := fmt.Sprintf("Unable to create NetData config! %v", err)
-			logger.Error(errmsg)
+			config.Logger.Error(errmsg)
 			panic(errmsg)
 		}
 	}
-	logger.Info("Running NetData")
+	config.Logger.Info("Running NetData")
 	info, err := StartContainer("netdata", "netdata")
 	if err != nil {
-		logger.Error(fmt.Sprintf("Error starting NetData: %v", err))
+		config.Logger.Error(fmt.Sprintf("Error starting NetData: %v", err))
 		return err
 	}
 	config.UpdateContainerState("netdata", info)

docker/urbit.go

@@ -17,15 +17,15 @@ import (
 
 // load existing urbits from config json
 func LoadUrbits() error {
-	logger.Info("Loading Urbit ships")
+	config.Logger.Info("Loading Urbit ships")
 	// Loop through pier list
 	conf := config.Conf()
 	for _, pier := range conf.Piers {
-		logger.Info(fmt.Sprintf("Loading pier %s", pier))
+		config.Logger.Info(fmt.Sprintf("Loading pier %s", pier))
 		// load json into struct
 		err := config.LoadUrbitConfig(pier)
 		if err != nil {
-			logger.Error(fmt.Sprintf("Error loading %s config: %v", pier, err))
+			config.Logger.Error(fmt.Sprintf("Error loading %s config: %v", pier, err))
 			continue
 		}
 		shipConf := config.UrbitConf(pier)
@@ -33,7 +33,7 @@ func LoadUrbits() error {
 		if shipConf.BootStatus != "noboot" {
 			info, err := StartContainer(pier, "vere")
 			if err != nil {
-				logger.Error(fmt.Sprintf("Error starting %s: %v", pier, err))
+				config.Logger.Error(fmt.Sprintf("Error starting %s: %v", pier, err))
 				continue
 			}
 			config.UpdateContainerState(pier, info)
@@ -86,7 +86,7 @@ func urbitContainerConf(containerName string) (container.Config, container.HostC
 		newConfig[containerName] = updateUrbitConf
 		err = config.UpdateUrbitConfig(newConfig)
 		if err != nil {
-			logger.Warn("Unable to reset %s boot script!", containerName)
+			config.Logger.Warn("Unable to reset %s boot script!", containerName)
 		}
 	}
 	// write the script

docker/wireguard.go

@@ -16,7 +16,7 @@ import (
 )
 
 func LoadWireguard() error {
-	logger.Info("Loading Startram Wireguard container")
+	config.Logger.Info("Loading Startram Wireguard container")
 	confPath := filepath.Join(config.BasePath, "settings", "wireguard.json")
 	_, err := os.Open(confPath)
 	if err != nil {
@@ -32,10 +32,10 @@ func LoadWireguard() error {
 	if err != nil {
 		return err
 	}
-	logger.Info("Running Wireguard")
+	config.Logger.Info("Running Wireguard")
 	info, err := StartContainer("wireguard", "wireguard")
 	if err != nil {
-		logger.Error(fmt.Sprintf("Error starting wireguard: %v", err))
+		config.Logger.Error(fmt.Sprintf("Error starting wireguard: %v", err))
 		return err
 	}
 	config.UpdateContainerState("wireguard", info)
@@ -89,12 +89,12 @@ func WriteWgConf() error {
 	existingConf, err := ioutil.ReadFile(filePath)
 	if err != nil {
 		// assume it doesn't exist, so write the current config
-		logger.Info("Creating WG config")
+		config.Logger.Info("Creating WG config")
 		return writeWgConfToFile(filePath, newConf)
 	}
 	if string(existingConf) != newConf {
 		// If they differ, overwrite
-		logger.Info("Updating WG config")
+		config.Logger.Info("Updating WG config")
 		return writeWgConfToFile(filePath, newConf)
 	}
 	return nil
@@ -167,7 +167,7 @@ func copyFileToVolume(filePath string, targetPath string, volumeName string) err
 	}
 	defer func() {
 		if removeErr := cli.ContainerRemove(ctx, resp.ID, types.ContainerRemoveOptions{Force: true}); removeErr != nil {
-			logger.Error("Failed to remove temporary container: ", removeErr)
+			config.Logger.Error("Failed to remove temporary container: ", removeErr)
 		}
 	}()
 	return nil

main.go

@@ -21,9 +21,7 @@ import (
 	"goseg/rectify"
 	"goseg/startram"
 	"goseg/ws"
-	"log/slog"
 	"net/http"
-	"os"
 	"strings"
 	"time"
 
@@ -31,14 +29,13 @@ import (
 )
 
 var (
-	logger  = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	DevMode = false
 )
 
 func loadService(loadFunc func() error, errMsg string) {
 	go func() {
 		if err := loadFunc(); err != nil {
-			logger.Error(fmt.Sprintf("%s %v", errMsg, err))
+			config.Logger.Error(fmt.Sprintf("%s %v", errMsg, err))
 		}
 	}()
 }
@@ -48,7 +45,7 @@ func main() {
 	conf := config.Conf()
 	internetAvailable := config.NetCheck("1.1.1.1:53")
 	availMsg := fmt.Sprintf("Internet available: %t", internetAvailable)
-	logger.Info(availMsg)
+	config.Logger.Info(availMsg)
 	// async operation to retrieve version info if updates are on
 	versionUpdateChannel := make(chan bool)
 	remoteVersion := false
@@ -58,7 +55,7 @@ func main() {
 		go func() {
 			_, versionUpdate := config.CheckVersion()
 			if versionUpdate {
-				logger.Info("Version info retrieved")
+				config.Logger.Info("Version info retrieved")
 			}
 			versionUpdateChannel <- versionUpdate
 		}()
@@ -78,22 +75,22 @@ func main() {
 	// just making sure we can parse (debug)
 	if len(conf.Piers) > 0 {
 		pierList := strings.Join(conf.Piers, ", ")
-		logger.Info(fmt.Sprintf("Loaded piers: %s", pierList))
+		config.Logger.Info(fmt.Sprintf("Loaded piers: %s", pierList))
 	}
 	// get the startram config from server
 	if conf.WgRegistered == true {
 		_, err := startram.Retrieve()
 		if err != nil {
-			logger.Warn(fmt.Sprintf("Could not retrieve StarTram/Anchor config: %v", err))
+			config.Logger.Warn(fmt.Sprintf("Could not retrieve StarTram/Anchor config: %v", err))
 		}
 	}
 	// block until version info returns
 	if remoteVersion == true {
 		select {
 		case <-versionUpdateChannel:
-			logger.Info("Version info retrieved")
+			config.Logger.Info("Version info retrieved")
 		case <-time.After(10 * time.Second):
-			logger.Warn("Could not retrieve version info after 10 seconds!")
+			config.Logger.Warn("Could not retrieve version info after 10 seconds!")
 			versionStruct := config.LocalVersion()
 			releaseChannel := conf.UpdateBranch
 			targetChan := versionStruct.Groundseg[releaseChannel]

rectify/rectify.go

@@ -8,16 +8,10 @@ import (
 	"goseg/broadcast"
 	"goseg/config"
 	"goseg/docker"
-	"log/slog"
-	"os"
 
 	"github.com/docker/docker/api/types/events"
 )
 
-var (
-	logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
-)
-
 // receives events via docker.EventBus
 // compares actual state to desired state
 func DockerSubscriptionHandler() {
@@ -25,14 +19,14 @@ func DockerSubscriptionHandler() {
 		event := <-docker.EventBus
 		dockerEvent, ok := event.Data.(events.Message)
 		if !ok {
-			logger.Error("Failed to assert Docker event data type")
+			config.Logger.Error("Failed to assert Docker event data type")
 			continue
 		}
 		contName := dockerEvent.Actor.Attributes["name"]
 		switch dockerEvent.Action {
 
 		case "stop":
-			logger.Info(fmt.Sprintf("Docker: %s stopped", contName))
+			config.Logger.Info(fmt.Sprintf("Docker: %s stopped", contName))
 
 			if containerState, exists := config.GetContainerState()[contName]; exists {
 				containerState.ActualStatus = "stopped"
@@ -45,7 +39,7 @@ func DockerSubscriptionHandler() {
 			}
 
 		case "start":
-			logger.Info(fmt.Sprintf("Docker: %s started", contName))
+			config.Logger.Info(fmt.Sprintf("Docker: %s started", contName))
 
 			if containerState, exists := config.GetContainerState()[contName]; exists {
 				containerState.ActualStatus = "running"
@@ -54,7 +48,7 @@ func DockerSubscriptionHandler() {
 			}
 
 		case "die":
-			logger.Warn(fmt.Sprintf("Docker: %s died!", contName))
+			config.Logger.Warn(fmt.Sprintf("Docker: %s died!", contName))
 			if containerState, exists := config.GetContainerState()[contName]; exists {
 				containerState.ActualStatus = "died"
 				// we don't want infinite restart loop
@@ -65,7 +59,7 @@ func DockerSubscriptionHandler() {
 
 		default:
 			if config.DebugMode == true {
-				logger.Info(fmt.Sprintf("%s event: %s", contName, dockerEvent.Action))
+				config.Logger.Info(fmt.Sprintf("%s event: %s", contName, dockerEvent.Action))
 			}
 		}
 	}

startram/startram.go

@@ -6,30 +6,24 @@ import (
 	"goseg/config"
 	"goseg/structs"
 	"io/ioutil"
-	"log/slog"
 	"net/http"
-	"os"
-)
-
-var (
-	logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 )
 
 func GetRegions() (map[string]structs.StartramRegion, error) {
 	var regions map[string]structs.StartramRegion
-	config := config.Conf()
-	regionUrl := "https://" + config.EndpointUrl + "/v1/regions"
+	conf := config.Conf()
+	regionUrl := "https://" + conf.EndpointUrl + "/v1/regions"
 	resp, err := http.Get(regionUrl)
 	if err != nil {
 		errmsg := fmt.Sprintf("Unable to connect to API server: %v", err)
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		return regions, err
 	}
 	body, err := ioutil.ReadAll(resp.Body)
 	resp.Body.Close()
 	if err != nil {
 		errmsg := fmt.Sprintf("Error reading regions info: %v", err)
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		return regions, err
 	}
 	// unmarshal values into struct
@@ -37,7 +31,7 @@ func GetRegions() (map[string]structs.StartramRegion, error) {
 	if err != nil {
 		errmsg := fmt.Sprintf("Error unmarshalling regions json: %v", err)
 		fmt.Println(string(body))
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		return regions, err
 	}
 	return regions, nil
@@ -50,7 +44,7 @@ func Retrieve() (structs.StartramRetrieve, error) {
 	resp, err := http.Get(regionUrl)
 	if err != nil {
 		errmsg := fmt.Sprintf("Unable to connect to API server: %v", err)
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		return retrieve, err
 	}
 	// read response body
@@ -58,7 +52,7 @@ func Retrieve() (structs.StartramRetrieve, error) {
 	resp.Body.Close()
 	if err != nil {
 		errmsg := fmt.Sprintf("Error reading retrieve info: %v", err)
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		return retrieve, err
 	}
 	// unmarshal values into struct
@@ -66,11 +60,11 @@ func Retrieve() (structs.StartramRetrieve, error) {
 	if err != nil {
 		errmsg := fmt.Sprintf("Error unmarshalling retrieve json: %v", err)
 		fmt.Println(string(body))
-		logger.Warn(errmsg)
+		config.Logger.Warn(errmsg)
 		return retrieve, err
 	}
 	// pin that ho to the global vars
 	config.StartramConfig = retrieve
-	logger.Info(fmt.Sprintf("StarTram info retrieved: %s", string(body)))
+	config.Logger.Info(fmt.Sprintf("StarTram info retrieved: %s", string(body)))
 	return retrieve, nil
 }

system/system.go

@@ -4,21 +4,16 @@ package system
 
 import (
 	"fmt"
+	"goseg/config"
 	"github.com/shirou/gopsutil/cpu"
 	"github.com/shirou/gopsutil/disk"
 	"github.com/shirou/gopsutil/mem"
 	"io/ioutil"
-	"log/slog"
-	"os"
 	"strconv"
 	"strings"
 	"time"
 )
 
-var (
-	logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
-)
-
 // get memory used/avail in bytes
 func GetMemory() (uint64, uint64) {
 	v, _ := mem.VirtualMemory()
@@ -42,14 +37,14 @@ func GetTemp() float64 {
 	data, err := ioutil.ReadFile("/sys/class/thermal/thermal_zone0/temp")
 	if err != nil {
 		errmsg := fmt.Sprintf("Error reading temperature:", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return 0
 	}
 	tempStr := strings.TrimSpace(string(data))
 	temp, err := strconv.Atoi(tempStr)
 	if err != nil {
 		errmsg := fmt.Sprintf("Error converting temperature to integer:", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return 0
 	}
 	return float64(temp) / 1000.0
@@ -60,7 +55,7 @@ func HasSwap() int {
 	data, err := ioutil.ReadFile("/proc/swaps")
 	if err != nil {
 		errmsg := fmt.Sprintf("Error reading swap status:", err)
-		logger.Error(errmsg)
+		config.Logger.Error(errmsg)
 		return 0
 	}
 	lines := strings.Split(string(data), "\n")

ws/ws.go

@@ -6,15 +6,13 @@ import (
 	"github.com/gorilla/websocket"
 	"goseg/auth"
 	"goseg/broadcast"
+	"goseg/config"
 	"goseg/structs"
-	"log/slog"
 	"net/http"
-	"os"
 	"time"
 )
 
 var (
-	logger   = slog.New(slog.NewJSONHandler(os.Stdout, nil))
 	upgrader = websocket.Upgrader{
 		ReadBufferSize:  1024,
 		WriteBufferSize: 1024,
@@ -25,14 +23,14 @@ var (
 //     // Read the first message from the client which should be the token
 //     messageType, p, err := c.ReadMessage()
 //     if err != nil {
-//         logger.Error(fmt.Errorf("%v",err))
+//         config.Logger.Error(fmt.Errorf("%v",err))
 //         return
 //     }
 //     token := string(p)
 //     // Verify the token
 //     isValid, _, err := CheckToken(token, c, false)  // 'false' assumes it's not a setup
 //     if !isValid || err != nil {
-//         logger.Info("Invalid token provided by client.")
+//         config.Logger.Info("Invalid token provided by client.")
 //         c.Close()
 //         return
 //     }
@@ -44,7 +42,7 @@ var (
 func WsHandler(w http.ResponseWriter, r *http.Request) {
 	conn, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
-		logger.Error(fmt.Sprintf("Couldn't upgrade websocket connection: %v", err))
+		config.Logger.Error(fmt.Sprintf("Couldn't upgrade websocket connection: %v", err))
 		return
 	}
 	// manage broadcasts and clients thru the broadcast package
@@ -82,44 +80,44 @@ func WsHandler(w http.ResponseWriter, r *http.Request) {
 		switch prelim.Payload.Type {
 		case "login":
 			if err = loginHandler(msg, payload); err != nil {
-				logger.Error(fmt.Sprintf("%v", err))
+				config.Logger.Error(fmt.Sprintf("%v", err))
 			}
 		case "verify":
 			if err = verifyHandler(msg, payload, r, conn); err != nil {
-				logger.Error(fmt.Sprintf("%v", err))
+				config.Logger.Error(fmt.Sprintf("%v", err))
 			}
 		case "setup":
-			logger.Info("Setup")
+			config.Logger.Info("Setup")
 			// setup.Setup(payload)
 		case "new_ship":
-			logger.Info("New ship")
+			config.Logger.Info("New ship")
 		case "pier_upload":
-			logger.Info("Pier upload")
+			config.Logger.Info("Pier upload")
 		case "password":
-			logger.Info("Password")
+			config.Logger.Info("Password")
 		case "system":
-			logger.Info("System")
+			config.Logger.Info("System")
 		case "startram":
-			logger.Info("StarTram")
+			config.Logger.Info("StarTram")
 		case "urbit":
-			logger.Info("Urbit")
+			config.Logger.Info("Urbit")
 		case "support":
-			logger.Info("Support")
+			config.Logger.Info("Support")
 		case "broadcast":
 			if err := broadcast.BroadcastToClients(); err != nil {
 				errmsg := fmt.Sprintf("Unable to broadcast to peer(s): %v", err)
-				logger.Error(errmsg)
+				config.Logger.Error(errmsg)
 			}
 		default:
 			errmsg := fmt.Sprintf("Unknown request type: %s", prelim.Payload.Type)
-			logger.Warn(errmsg)
+			config.Logger.Warn(errmsg)
 		}
 	}
 }
 
 // validate password and add to auth session
 func loginHandler(msg []byte, payload structs.WsPayload) error {
-	logger.Info("Login")
+	config.Logger.Info("Login")
 	now := time.Now().Format("2006-01-02_15:04:05")
 	payload.Payload = structs.WsLoginPayload{}
 	if err := json.Unmarshal(msg, &payload); err != nil {
@@ -135,13 +133,13 @@ func loginHandler(msg []byte, payload structs.WsPayload) error {
 			return fmt.Errorf("Unable to process login: %v", err)
 		}
 	} else {
-		logger.Info("Login failed")
+		config.Logger.Info("Login failed")
 	}
 	return nil
 }
 
 func verifyHandler(msg []byte, payload structs.WsPayload, r *http.Request, conn *websocket.Conn) error {
-	logger.Info("Verify")
+	config.Logger.Info("Verify")
 	payload.Payload = structs.WsLoginPayload{}
 	// if we can't unmarshal, assume no token
 	if err := json.Unmarshal(msg, &payload); err != nil {