Merge pull request #1387 from gravitl/feature_v0.14.6_netmaker_logs

Feature v0.14.6 netmaker logs

controllers/dns.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -24,67 +25,69 @@ func dnsHandlers(r *mux.Router) {
 	r.HandleFunc("/api/dns/{network}/{domain}", securityCheck(false, http.HandlerFunc(deleteDNS))).Methods("DELETE")
 }
 
-//Gets all nodes associated with network, including pending nodes
+//Gets node DNS entries associated with a network
 func getNodeDNS(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
 	var dns []models.DNSEntry
 	var params = mux.Vars(r)
-
-	dns, err := logic.GetNodeDNS(params["network"])
+	network := params["network"]
+	dns, err := logic.GetNodeDNS(network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get node DNS entries for network [%s]: %v", network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
-	//Returns all the nodes in JSON format
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(dns)
 }
 
-//Gets all nodes associated with network, including pending nodes
+//Gets all DNS entries.
 func getAllDNS(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	dns, err := logic.GetAllDNS()
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "failed to get all DNS entries: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	//Returns all the nodes in JSON format
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(dns)
 }
 
-//Gets all nodes associated with network, including pending nodes
+//Gets custom DNS entries associated with a network
 func getCustomDNS(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
 	var dns []models.DNSEntry
 	var params = mux.Vars(r)
-
-	dns, err := logic.GetCustomDNS(params["network"])
+	network := params["network"]
+	dns, err := logic.GetCustomDNS(network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get custom DNS entries for network [%s]: %v", network, err.Error()))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
-	//Returns all the nodes in JSON format
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(dns)
 }
 
-// Gets all nodes associated with network, including pending nodes
+// Gets all DNS entries associated with the network
 func getDNS(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
 	var dns []models.DNSEntry
 	var params = mux.Vars(r)
-
-	dns, err := logic.GetDNS(params["network"])
+	network := params["network"]
+	dns, err := logic.GetDNS(network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get all DNS entries for network [%s]: %v", network, err.Error()))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -98,23 +101,28 @@ func createDNS(w http.ResponseWriter, r *http.Request) {
 	var entry models.DNSEntry
 	var params = mux.Vars(r)
 
-	//get node from body of request
 	_ = json.NewDecoder(r.Body).Decode(&entry)
 	entry.Network = params["network"]
 
 	err := logic.ValidateDNSCreate(entry)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("invalid DNS entry %+v: %v", entry, err))
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 
 	entry, err = CreateDNS(entry)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("Failed to create DNS entry %+v: %v", entry, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	err = logic.SetDNS()
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("Failed to set DNS entries on file: %v", err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -132,6 +140,8 @@ func createDNS(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 	}
+	logger.Log(2, r.Header.Get("user"),
+		fmt.Sprintf("DNS entry is set: %+v", entry))
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(entry)
 }
@@ -142,17 +152,19 @@ func deleteDNS(w http.ResponseWriter, r *http.Request) {
 
 	// get params
 	var params = mux.Vars(r)
-
+	entrytext := params["domain"] + "." + params["network"]
 	err := logic.DeleteDNS(params["domain"], params["network"])
 
 	if err != nil {
+		logger.Log(0, "failed to delete dns entry: ", entrytext)
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	entrytext := params["domain"] + "." + params["network"]
 	logger.Log(1, "deleted dns entry: ", entrytext)
 	err = logic.SetDNS()
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("Failed to set DNS entries on file: %v", err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -197,6 +209,8 @@ func pushDNS(w http.ResponseWriter, r *http.Request) {
 	err := logic.SetDNS()
 
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("Failed to set DNS entries on file: %v", err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}

controllers/ext_client.go

@@ -43,8 +43,11 @@ func getNetworkExtClients(w http.ResponseWriter, r *http.Request) {
 
 	var extclients []models.ExtClient
 	var params = mux.Vars(r)
-	extclients, err := logic.GetNetworkExtClients(params["network"])
+	network := params["network"]
+	extclients, err := logic.GetNetworkExtClients(network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get ext clients for network [%s]: %v", network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -64,6 +67,8 @@ func getAllExtClients(w http.ResponseWriter, r *http.Request) {
 	networksSlice := []string{}
 	marshalErr := json.Unmarshal([]byte(headerNetworks), &networksSlice)
 	if marshalErr != nil {
+		logger.Log(0, "error unmarshalling networks: ",
+			marshalErr.Error())
 		returnErrorResponse(w, r, formatError(marshalErr, "internal"))
 		return
 	}
@@ -72,6 +77,7 @@ func getAllExtClients(w http.ResponseWriter, r *http.Request) {
 	if networksSlice[0] == ALL_NETWORK_ACCESS {
 		clients, err = functions.GetAllExtClients()
 		if err != nil && !database.IsEmptyRecord(err) {
+			logger.Log(0, "failed to get all extclients: ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -100,6 +106,8 @@ func getExtClient(w http.ResponseWriter, r *http.Request) {
 	network := params["network"]
 	client, err := logic.GetExtClient(clientid, network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to get extclient for [%s] on network [%s]: %v",
+			clientid, network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -118,13 +126,16 @@ func getExtClientConf(w http.ResponseWriter, r *http.Request) {
 	networkid := params["network"]
 	client, err := logic.GetExtClient(clientid, networkid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to get extclient for [%s] on network [%s]: %v",
+			clientid, networkid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
 	gwnode, err := logic.GetNodeByID(client.IngressGatewayID)
 	if err != nil {
-		logger.Log(1, r.Header.Get("user"), "Could not retrieve Ingress Gateway Node", client.IngressGatewayID)
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get ingress gateway node [%s] info: %v", client.IngressGatewayID, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -197,6 +208,7 @@ Endpoint = %s
 	if params["type"] == "qr" {
 		bytes, err := qrcode.Encode(config, qrcode.Medium, 220)
 		if err != nil {
+			logger.Log(1, r.Header.Get("user"), "failed to encode qr code: ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -204,6 +216,7 @@ Endpoint = %s
 		w.WriteHeader(http.StatusOK)
 		_, err = w.Write(bytes)
 		if err != nil {
+			logger.Log(1, r.Header.Get("user"), "response writer error (qr) ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -217,6 +230,7 @@ Endpoint = %s
 		w.WriteHeader(http.StatusOK)
 		_, err := fmt.Fprint(w, config)
 		if err != nil {
+			logger.Log(1, r.Header.Get("user"), "response writer error (file) ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 		}
 		return
@@ -239,7 +253,10 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 	nodeid := params["nodeid"]
 	ingressExists := checkIngressExists(nodeid)
 	if !ingressExists {
-		returnErrorResponse(w, r, formatError(errors.New("ingress does not exist"), "internal"))
+		err := errors.New("ingress does not exist")
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create extclient on network [%s]: %v", networkName, err))
+		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
@@ -248,6 +265,8 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 	extclient.IngressGatewayID = nodeid
 	node, err := logic.GetNodeByID(nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get ingress gateway node [%s] info: %v", nodeid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -260,6 +279,8 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 	}
 	err = logic.CreateExtClient(&extclient)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create new ext client on network [%s]: %v", networkName, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -278,25 +299,43 @@ func updateExtClient(w http.ResponseWriter, r *http.Request) {
 
 	var newExtClient models.ExtClient
 	var oldExtClient models.ExtClient
-	_ = json.NewDecoder(r.Body).Decode(&newExtClient)
-
-	key, err := logic.GetRecordKey(params["clientid"], params["network"])
+	err := json.NewDecoder(r.Body).Decode(&newExtClient)
+	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+	clientid := params["clientid"]
+	network := params["network"]
+	key, err := logic.GetRecordKey(clientid, network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get record key for client [%s], network [%s]: %v",
+				clientid, network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	data, err := database.FetchRecord(database.EXT_CLIENT_TABLE_NAME, key)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to fetch  ext client record key [%s] from db for client [%s], network [%s]: %v",
+				key, clientid, network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	if err = json.Unmarshal([]byte(data), &oldExtClient); err != nil {
+		logger.Log(0, "error unmarshalling extclient: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	var changedEnabled = newExtClient.Enabled != oldExtClient.Enabled // indicates there was a change in enablement
 	newclient, err := logic.UpdateExtClient(newExtClient.ClientID, params["network"], newExtClient.Enabled, &oldExtClient)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to update ext client [%s], network [%s]: %v",
+				clientid, network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -320,22 +359,28 @@ func deleteExtClient(w http.ResponseWriter, r *http.Request) {
 
 	// get params
 	var params = mux.Vars(r)
-
-	extclient, err := logic.GetExtClient(params["clientid"], params["network"])
+	clientid := params["clientid"]
+	network := params["network"]
+	extclient, err := logic.GetExtClient(clientid, network)
 	if err != nil {
 		err = errors.New("Could not delete extclient " + params["clientid"])
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete extclient [%s],network [%s]: %v", clientid, network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	ingressnode, err := logic.GetNodeByID(extclient.IngressGatewayID)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get ingress gateway node [%s] info: %v", extclient.IngressGatewayID, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
 	err = logic.DeleteExtClient(params["network"], params["clientid"])
-
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete extclient [%s],network [%s]: %v", clientid, network, err))
 		err = errors.New("Could not delete extclient " + params["clientid"])
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return

controllers/network.go

@@ -46,7 +46,9 @@ func getNetworks(w http.ResponseWriter, r *http.Request) {
 	networksSlice := []string{}
 	marshalErr := json.Unmarshal([]byte(headerNetworks), &networksSlice)
 	if marshalErr != nil {
-		returnErrorResponse(w, r, formatError(marshalErr, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error unmarshalling networks: ",
+			marshalErr.Error())
+		returnErrorResponse(w, r, formatError(marshalErr, "badrequest"))
 		return
 	}
 	allnetworks := []models.Network{}
@@ -54,6 +56,7 @@ func getNetworks(w http.ResponseWriter, r *http.Request) {
 	if networksSlice[0] == ALL_NETWORK_ACCESS {
 		allnetworks, err = logic.GetNetworks()
 		if err != nil && !database.IsEmptyRecord(err) {
+			logger.Log(0, r.Header.Get("user"), "failed to fetch networks: ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -85,6 +88,8 @@ func getNetwork(w http.ResponseWriter, r *http.Request) {
 	netname := params["networkname"]
 	network, err := logic.GetNetwork(netname)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to fetch network [%s] info: %v",
+			netname, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -102,6 +107,8 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
 	netname := params["networkname"]
 	network, err := logic.KeyUpdate(netname)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to update keys for network [%s]: %v",
+			netname, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -110,7 +117,7 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(network)
 	nodes, err := logic.GetNetworkNodes(netname)
 	if err != nil {
-		logger.Log(2, "failed to retrieve network nodes for network", netname, err.Error())
+		logger.Log(0, "failed to retrieve network nodes for network", netname, err.Error())
 		return
 	}
 	for _, node := range nodes {
@@ -132,12 +139,16 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 
 	network, err := logic.GetParentNetwork(netname)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "failed to get network info: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	var newNetwork models.Network
 	err = json.NewDecoder(r.Body).Decode(&newNetwork)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -149,6 +160,8 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 
 	rangeupdate4, rangeupdate6, localrangeupdate, holepunchupdate, err := logic.UpdateNetwork(&network, &newNetwork)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "failed to update network: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -156,6 +169,9 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 	if rangeupdate4 {
 		err = logic.UpdateNetworkNodeAddresses(network.NetID)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				fmt.Sprintf("failed to update network [%s] ipv4 addresses: %v",
+					network.NetID, err.Error()))
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -163,6 +179,9 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 	if rangeupdate6 {
 		err = logic.UpdateNetworkNodeAddresses6(network.NetID)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				fmt.Sprintf("failed to update network [%s] ipv6 addresses: %v",
+					network.NetID, err.Error()))
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -170,6 +189,9 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 	if localrangeupdate {
 		err = logic.UpdateNetworkLocalAddresses(network.NetID)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				fmt.Sprintf("failed to update network [%s] local addresses: %v",
+					network.NetID, err.Error()))
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -177,6 +199,9 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 	if holepunchupdate {
 		err = logic.UpdateNetworkHolePunching(network.NetID, newNetwork.DefaultUDPHolePunch)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				fmt.Sprintf("failed to update network [%s] hole punching: %v",
+					network.NetID, err.Error()))
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -184,6 +209,9 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 	if rangeupdate4 || rangeupdate6 || localrangeupdate || holepunchupdate {
 		nodes, err := logic.GetNetworkNodes(network.NetID)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				fmt.Sprintf("failed to get network [%s] nodes: %v",
+					network.NetID, err.Error()))
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -206,18 +234,28 @@ func updateNetworkNodeLimit(w http.ResponseWriter, r *http.Request) {
 	netname := params["networkname"]
 	network, err := logic.GetParentNetwork(netname)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get network [%s] nodes: %v",
+				network.NetID, err.Error()))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
 	var networkChange models.Network
 
-	_ = json.NewDecoder(r.Body).Decode(&networkChange)
-
+	err = json.NewDecoder(r.Body).Decode(&networkChange)
+	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
 	if networkChange.NodeLimit != 0 {
 		network.NodeLimit = networkChange.NodeLimit
 		data, err := json.Marshal(&network)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				"error marshalling resp: ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "badrequest"))
 			return
 		}
@@ -235,12 +273,22 @@ func updateNetworkACL(w http.ResponseWriter, r *http.Request) {
 	var networkACLChange acls.ACLContainer
 	networkACLChange, err := networkACLChange.Get(acls.ContainerID(netname))
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to fetch ACLs for network [%s]: %v", netname, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	_ = json.NewDecoder(r.Body).Decode(&networkACLChange)
+	err = json.NewDecoder(r.Body).Decode(&networkACLChange)
+	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
 	newNetACL, err := networkACLChange.Save(acls.ContainerID(netname))
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to update ACLs for network [%s]: %v", netname, err))
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -272,6 +320,8 @@ func getNetworkACL(w http.ResponseWriter, r *http.Request) {
 	var networkACL acls.ACLContainer
 	networkACL, err := networkACL.Get(acls.ContainerID(netname))
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to fetch ACLs for network [%s]: %v", netname, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -294,6 +344,8 @@ func deleteNetwork(w http.ResponseWriter, r *http.Request) {
 		if strings.Contains(err.Error(), "Node check failed") {
 			errtype = "forbidden"
 		}
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete network [%s]: %v", network, err))
 		returnErrorResponse(w, r, formatError(err, errtype))
 		return
 	}
@@ -311,17 +363,24 @@ func createNetwork(w http.ResponseWriter, r *http.Request) {
 	// we decode our body request params
 	err := json.NewDecoder(r.Body).Decode(&network)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 
 	if network.AddressRange == "" && network.AddressRange6 == "" {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("IPv4 or IPv6 CIDR required"), "badrequest"))
+		err := errors.New("IPv4 or IPv6 CIDR required")
+		logger.Log(0, r.Header.Get("user"), "failed to create network: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 
 	network, err = logic.CreateNetwork(network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "failed to create network: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -333,6 +392,8 @@ func createNetwork(w http.ResponseWriter, r *http.Request) {
 			if err == nil {
 				err = errors.New("Failed to add server to network " + network.NetID)
 			}
+			logger.Log(0, r.Header.Get("user"), "failed to create network: ",
+				err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -352,16 +413,22 @@ func createAccessKey(w http.ResponseWriter, r *http.Request) {
 	netname := params["networkname"]
 	network, err := logic.GetParentNetwork(netname)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "failed to get network info: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	err = json.NewDecoder(r.Body).Decode(&accesskey)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	key, err := logic.CreateAccessKey(accesskey, network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "failed to create access key: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -377,6 +444,8 @@ func getAccessKeys(w http.ResponseWriter, r *http.Request) {
 	network := params["networkname"]
 	keys, err := logic.GetKeys(network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to get keys for network [%s]: %v",
+			network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -396,6 +465,8 @@ func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
 	netname := params["networkname"]
 	err := logic.DeleteKey(keyname, netname)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), fmt.Sprintf("failed to delete key [%s] for network [%s]: %v",
+			keyname, netname, err))
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}

controllers/node.go

@@ -51,16 +51,20 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 	if decoderErr != nil {
 		errorResponse.Code = http.StatusBadRequest
 		errorResponse.Message = decoderErr.Error()
+		logger.Log(0, request.Header.Get("user"), "error decoding request body: ",
+			decoderErr.Error())
 		returnErrorResponse(response, request, errorResponse)
 		return
 	} else {
 		errorResponse.Code = http.StatusBadRequest
 		if authRequest.ID == "" {
 			errorResponse.Message = "W1R3: ID can't be empty"
+			logger.Log(0, request.Header.Get("user"), errorResponse.Message)
 			returnErrorResponse(response, request, errorResponse)
 			return
 		} else if authRequest.Password == "" {
 			errorResponse.Message = "W1R3: Password can't be empty"
+			logger.Log(0, request.Header.Get("user"), errorResponse.Message)
 			returnErrorResponse(response, request, errorResponse)
 			return
 		} else {
@@ -70,6 +74,8 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 			if err != nil {
 				errorResponse.Code = http.StatusBadRequest
 				errorResponse.Message = err.Error()
+				logger.Log(0, request.Header.Get("user"),
+					fmt.Sprintf("failed to get node info [%s]: %v", authRequest.ID, err))
 				returnErrorResponse(response, request, errorResponse)
 				return
 			}
@@ -78,14 +84,18 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 			if err != nil {
 				errorResponse.Code = http.StatusBadRequest
 				errorResponse.Message = err.Error()
+				logger.Log(0, request.Header.Get("user"),
+					"error validating user password: ", err.Error())
 				returnErrorResponse(response, request, errorResponse)
 				return
 			} else {
-				tokenString, _ := logic.CreateJWT(authRequest.ID, authRequest.MacAddress, result.Network)
+				tokenString, err := logic.CreateJWT(authRequest.ID, authRequest.MacAddress, result.Network)
 
 				if tokenString == "" {
 					errorResponse.Code = http.StatusBadRequest
 					errorResponse.Message = "Could not create Token"
+					logger.Log(0, request.Header.Get("user"),
+						fmt.Sprintf("%s: %v", errorResponse.Message, err))
 					returnErrorResponse(response, request, errorResponse)
 					return
 				}
@@ -103,6 +113,8 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 				if jsonError != nil {
 					errorResponse.Code = http.StatusBadRequest
 					errorResponse.Message = err.Error()
+					logger.Log(0, request.Header.Get("user"),
+						"error marshalling resp: ", err.Error())
 					returnErrorResponse(response, request, errorResponse)
 					return
 				}
@@ -301,6 +313,8 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
 
 	nodes, err := logic.GetNetworkNodes(networkName)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching nodes on network %s: %v", networkName, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -317,6 +331,8 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	user, err := logic.GetUser(r.Header.Get("user"))
 	if err != nil && r.Header.Get("ismasterkey") != "yes" {
+		logger.Log(0, r.Header.Get("user"),
+			"error fetching user info: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -324,12 +340,15 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
 	if user.IsAdmin || r.Header.Get("ismasterkey") == "yes" {
 		nodes, err = logic.GetAllNodes()
 		if err != nil {
+			logger.Log(0, "error fetching all nodes info: ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
 	} else {
 		nodes, err = getUsersNodes(user)
 		if err != nil {
+			logger.Log(0, r.Header.Get("user"),
+				"error fetching nodes: ", err.Error())
 			returnErrorResponse(w, r, formatError(err, "internal"))
 			return
 		}
@@ -359,15 +378,19 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	var params = mux.Vars(r)
-
-	node, err := logic.GetNodeByID(params["nodeid"])
+	nodeid := params["nodeid"]
+	node, err := logic.GetNodeByID(nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching node [ %s ] info: %v", nodeid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
 	peerUpdate, err := logic.GetPeerUpdate(&node)
 	if err != nil && !database.IsEmptyRecord(err) {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching wg peers config for node [ %s ]: %v", nodeid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -392,8 +415,11 @@ func getLastModified(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	var params = mux.Vars(r)
-	network, err := logic.GetNetwork(params["network"])
+	networkName := params["network"]
+	network, err := logic.GetNetwork(networkName)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching network [%s] info: %v", networkName, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -414,12 +440,16 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	networkexists, err := functions.NetworkExists(networkName)
 
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to fetch network [%s] info: %v", networkName, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	} else if !networkexists {
 		errorResponse = models.ErrorResponse{
 			Code: http.StatusNotFound, Message: "W1R3: Network does not exist! ",
 		}
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("network [%s] does not exist", networkName))
 		returnErrorResponse(w, r, errorResponse)
 		return
 	}
@@ -429,7 +459,8 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	//get node from body of request
 	err = json.NewDecoder(r.Body).Decode(&node)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 
@@ -437,11 +468,15 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 
 	network, err := logic.GetNetworkByNode(&node)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get network [%s] info: %v", node.Network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to get network [%s] settings: %v", node.Network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -455,6 +490,9 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 			errorResponse = models.ErrorResponse{
 				Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
 			}
+			logger.Log(0, r.Header.Get("user"),
+				fmt.Sprintf("failed to create node on network [%s]: %s",
+					node.Network, errorResponse.Message))
 			returnErrorResponse(w, r, errorResponse)
 			return
 		}
@@ -482,12 +520,17 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 
 	err = logic.CreateNode(&node)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create node on network [%s]: %s",
+				node.Network, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
 	peerUpdate, err := logic.GetPeerUpdate(&node)
 	if err != nil && !database.IsEmptyRecord(err) {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching wg peers config for node [ %s ]: %v", node.ID, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -512,6 +555,8 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
 	var nodeid = params["nodeid"]
 	node, err := logic.UncordonNode(nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to uncordon node [%s]: %v", node.Name, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -530,13 +575,17 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	err := json.NewDecoder(r.Body).Decode(&gateway)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	gateway.NetID = params["network"]
 	gateway.NodeID = params["nodeid"]
 	node, err := logic.CreateEgressGateway(gateway)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create egress gateway on node [%s] on network [%s]: %v",
+				gateway.NodeID, gateway.NetID, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -555,11 +604,14 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
 	netid := params["network"]
 	node, err := logic.DeleteEgressGateway(netid, nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete egress gateway on node [%s] on network [%s]: %v",
+				nodeid, netid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
-	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
+	logger.Log(1, r.Header.Get("user"), "deleted egress gateway on node", nodeid, "on network", netid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 
@@ -575,6 +627,9 @@ func createIngressGateway(w http.ResponseWriter, r *http.Request) {
 	netid := params["network"]
 	node, err := logic.CreateIngressGateway(netid, nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create ingress gateway on node [%s] on network [%s]: %v",
+				nodeid, netid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -590,8 +645,12 @@ func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
 	nodeid := params["nodeid"]
-	node, err := logic.DeleteIngressGateway(params["network"], nodeid)
+	netid := params["network"]
+	node, err := logic.DeleteIngressGateway(netid, nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete ingress gateway on node [%s] on network [%s]: %v",
+				nodeid, netid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -610,8 +669,11 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 
 	var node models.Node
 	//start here
-	node, err := logic.GetNodeByID(params["nodeid"])
+	nodeid := params["nodeid"]
+	node, err := logic.GetNodeByID(nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching node [ %s ] info: %v", nodeid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -620,6 +682,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&newNode)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -666,6 +729,8 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 
 	err = logic.UpdateNode(&node, &newNode)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to update node info [ %s ] info: %v", nodeid, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -703,11 +768,16 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 	var nodeid = params["nodeid"]
 	var node, err = logic.GetNodeByID(nodeid)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("error fetching node [ %s ] info: %v", nodeid, err))
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	if isServer(&node) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("cannot delete server node"), "badrequest"))
+		err := fmt.Errorf("cannot delete server node")
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete node [ %s ]: %v", nodeid, err))
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	//send update to node to be deleted before deleting on server otherwise message cannot be sent

controllers/relay.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -17,13 +18,16 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	err := json.NewDecoder(r.Body).Decode(&relay)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	relay.NetID = params["network"]
 	relay.NodeID = params["nodeid"]
 	updatenodes, node, err := logic.CreateRelay(relay)
 	if err != nil {
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create relay on node [%s] on network [%s]: %v", relay.NodeID, relay.NetID, err))
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -46,7 +50,8 @@ func deleteRelay(w http.ResponseWriter, r *http.Request) {
 	netid := params["network"]
 	updatenodes, node, err := logic.DeleteRelay(netid, nodeid)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	logger.Log(1, r.Header.Get("user"), "deleted relay server", nodeid, "on network", netid)

controllers/server.go

@@ -73,14 +73,17 @@ func removeNetwork(w http.ResponseWriter, r *http.Request) {
 
 	// get params
 	var params = mux.Vars(r)
-
-	err := logic.DeleteNetwork(params["network"])
+	network := params["network"]
+	err := logic.DeleteNetwork(network)
 	if err != nil {
-		json.NewEncoder(w).Encode("Could not remove server from network " + params["network"])
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to delete network [%s]: %v", network, err))
+		json.NewEncoder(w).Encode(fmt.Sprintf("could not remove network %s from server", network))
 		return
 	}
-
-	json.NewEncoder(w).Encode("Server removed from network " + params["network"])
+	logger.Log(1, r.Header.Get("user"),
+		fmt.Sprintf("deleted network [%s]: %v", network, err))
+	json.NewEncoder(w).Encode(fmt.Sprintf("network %s removed from server", network))
 }
 
 func getServerInfo(w http.ResponseWriter, r *http.Request) {
@@ -137,6 +140,8 @@ func register(w http.ResponseWriter, r *http.Request) {
 		Broker:     servercfg.GetServer(),
 		Port:       servercfg.GetMQPort(),
 	}
+	logger.Log(2, r.Header.Get("user"),
+		fmt.Sprintf("registered client [%+v] with server", request))
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(response)
 }

controllers/user.go

@@ -44,23 +44,27 @@ func authenticateUser(response http.ResponseWriter, request *http.Request) {
 	decoderErr := decoder.Decode(&authRequest)
 	defer request.Body.Close()
 	if decoderErr != nil {
+		logger.Log(0, "error decoding request body: ",
+			decoderErr.Error())
 		returnErrorResponse(response, request, errorResponse)
 		return
 	}
-
+	username := authRequest.UserName
 	jwt, err := logic.VerifyAuthRequest(authRequest)
 	if err != nil {
+		logger.Log(0, username, "user validation failed: ",
+			err.Error())
 		returnErrorResponse(response, request, formatError(err, "badrequest"))
 		return
 	}
 
 	if jwt == "" {
 		// very unlikely that err is !nil and no jwt returned, but handle it anyways.
+		logger.Log(0, username, "jwt token is empty")
 		returnErrorResponse(response, request, formatError(errors.New("no token returned"), "internal"))
 		return
 	}
 
-	username := authRequest.UserName
 	var successResponse = models.SuccessResponse{
 		Code:    http.StatusOK,
 		Message: "W1R3: Device " + username + " Authorized",
@@ -73,6 +77,8 @@ func authenticateUser(response http.ResponseWriter, request *http.Request) {
 	successJSONResponse, jsonError := json.Marshal(successResponse)
 
 	if jsonError != nil {
+		logger.Log(0, username,
+			"error marshalling resp: ", err.Error())
 		returnErrorResponse(response, request, errorResponse)
 		return
 	}
@@ -87,6 +93,7 @@ func hasAdmin(w http.ResponseWriter, r *http.Request) {
 
 	hasadmin, err := logic.HasAdmin()
 	if err != nil {
+		logger.Log(0, "failed to check for admin: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -109,7 +116,7 @@ func GetUserInternal(username string) (models.User, error) {
 	return user, err
 }
 
-// Get an individual node. Nothin fancy here folks.
+// Get an individual user. Nothin fancy here folks.
 func getUser(w http.ResponseWriter, r *http.Request) {
 	// set header.
 	w.Header().Set("Content-Type", "application/json")
@@ -119,6 +126,7 @@ func getUser(w http.ResponseWriter, r *http.Request) {
 	user, err := logic.GetUser(usernameFetched)
 
 	if err != nil {
+		logger.Log(0, usernameFetched, "failed to fetch user: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -126,7 +134,7 @@ func getUser(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(user)
 }
 
-// Get an individual node. Nothin fancy here folks.
+// Get all users. Nothin fancy here folks.
 func getUsers(w http.ResponseWriter, r *http.Request) {
 	// set header.
 	w.Header().Set("Content-Type", "application/json")
@@ -134,6 +142,7 @@ func getUsers(w http.ResponseWriter, r *http.Request) {
 	users, err := logic.GetUsers()
 
 	if err != nil {
+		logger.Log(0, "failed to fetch users: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -146,12 +155,20 @@ func createAdmin(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	var admin models.User
-	// get node from body of request
-	_ = json.NewDecoder(r.Body).Decode(&admin)
 
-	admin, err := logic.CreateAdmin(admin)
+	err := json.NewDecoder(r.Body).Decode(&admin)
+	if err != nil {
+
+		logger.Log(0, admin.UserName, "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+	admin, err = logic.CreateAdmin(admin)
 
 	if err != nil {
+		logger.Log(0, admin.UserName, "failed to create admin: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -163,12 +180,17 @@ func createUser(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	var user models.User
-	// get node from body of request
-	_ = json.NewDecoder(r.Body).Decode(&user)
-
-	user, err := logic.CreateUser(user)
-
+	err := json.NewDecoder(r.Body).Decode(&user)
+	if err != nil {
+		logger.Log(0, user.UserName, "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		return
+	}
+	user, err = logic.CreateUser(user)
 	if err != nil {
+		logger.Log(0, user.UserName, "error creating new user: ",
+			err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -184,6 +206,8 @@ func updateUserNetworks(w http.ResponseWriter, r *http.Request) {
 	username := params["username"]
 	user, err := GetUserInternal(username)
 	if err != nil {
+		logger.Log(0, username,
+			"failed to update user networks: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -191,11 +215,15 @@ func updateUserNetworks(w http.ResponseWriter, r *http.Request) {
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&userchange)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, username, "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	err = logic.UpdateUserNetworks(userchange.Networks, userchange.IsAdmin, &user)
 	if err != nil {
+		logger.Log(0, username,
+			"failed to update user networks: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -211,23 +239,31 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 	username := params["username"]
 	user, err := GetUserInternal(username)
 	if err != nil {
+		logger.Log(0, username,
+			"failed to update user info: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 	if auth.IsOauthUser(&user) == nil {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not update user info for oauth user %s", username), "forbidden"))
+		err := fmt.Errorf("cannot update user info for oauth user %s", username)
+		logger.Log(0, err.Error())
+		returnErrorResponse(w, r, formatError(err, "forbidden"))
 		return
 	}
 	var userchange models.User
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&userchange)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, username, "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 	userchange.Networks = nil
 	user, err = logic.UpdateUser(userchange, user)
 	if err != nil {
+		logger.Log(0, username,
+			"failed to update user info: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -247,18 +283,28 @@ func updateUserAdm(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if auth.IsOauthUser(&user) != nil {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not update user info for oauth user"), "forbidden"))
+		err := fmt.Errorf("cannot update user info for oauth user %s", username)
+		logger.Log(0, err.Error())
+		returnErrorResponse(w, r, formatError(err, "forbidden"))
 		return
 	}
 	var userchange models.User
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&userchange)
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
+		logger.Log(0, username, "error decoding request body: ",
+			err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
+	if !user.IsAdmin {
+		logger.Log(0, username, "not an admin user")
+		returnErrorResponse(w, r, formatError(errors.New("not a admin user"), "badrequest"))
+	}
 	user, err = logic.UpdateUser(userchange, user)
 	if err != nil {
+		logger.Log(0, username,
+			"failed to update user (admin) info: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
@@ -274,13 +320,17 @@ func deleteUser(w http.ResponseWriter, r *http.Request) {
 	var params = mux.Vars(r)
 
 	username := params["username"]
-	success, err := logic.DeleteUser(username)
 
+	success, err := logic.DeleteUser(username)
 	if err != nil {
+		logger.Log(0, username,
+			"failed to delete user: ", err.Error())
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	} else if !success {
-		returnErrorResponse(w, r, formatError(errors.New("delete unsuccessful"), "badrequest"))
+		err := errors.New("delete unsuccessful")
+		logger.Log(0, username, err.Error())
+		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
 

logger/logger.go

@@ -4,7 +4,9 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"sort"
+	"strings"
 	"sync"
 	"time"
 )
@@ -34,9 +36,29 @@ func Log(verbosity int, message ...string) {
 	defer mu.Unlock()
 	var currentTime = time.Now()
 	var currentMessage = MakeString(" ", message...)
+
+	if getVerbose() >= 4 {
+		pc, file, line, ok := runtime.Caller(1)
+		if !ok {
+			file = "?"
+			line = 0
+		}
+
+		fn := runtime.FuncForPC(pc)
+		var fnName string
+		if fn == nil {
+			fnName = "?()"
+		} else {
+			fnName = strings.TrimLeft(filepath.Ext(fn.Name()), ".") + "()"
+		}
+		currentMessage = fmt.Sprintf("[%s-%d] %s: %s",
+			filepath.Base(file), line, fnName, currentMessage)
+	}
+
 	if int32(verbosity) <= getVerbose() && getVerbose() >= 0 {
 		fmt.Printf("[%s] %s %s \n", program, currentTime.Format(TimeFormat), currentMessage)
 	}
+
 	if program == "netmaker" {
 		currentLogs[currentMessage] = entry{
 			Time:  currentTime.Format("2006-01-02 15:04:05.999999999"),

logger/util.go

@@ -22,7 +22,7 @@ func MakeString(delimeter string, message ...string) string {
 }
 
 func getVerbose() int32 {
-	if Verbosity >= 1 && Verbosity <= 3 {
+	if Verbosity >= 1 && Verbosity <= 4 {
 		return int32(Verbosity)
 	}
 	Verbosity = int(servercfg.GetVerbosity())

mq/publishers.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
@@ -117,7 +118,7 @@ func sendPeers() {
 		}
 	}
 	networks, err := logic.GetNetworks()
-	if err != nil {
+	if err != nil && !database.IsEmptyRecord(err) {
 		logger.Log(1, "error retrieving networks for keepalive", err.Error())
 	}
 

netclient/cli_options/cmds.go

@@ -90,7 +90,7 @@ func GetCommands(cliFlags []cli.Flag) []*cli.Command {
 			Flags: cliFlags,
 			Action: func(c *cli.Context) error {
 				// set max verbosity for daemon regardless
-				logger.Verbosity = 3
+				logger.Verbosity = 4
 				err := command.Daemon()
 				return err
 			},
@@ -116,5 +116,7 @@ func parseVerbosity(c *cli.Context) {
 		logger.Verbosity = 2
 	} else if c.Bool("vvv") {
 		logger.Verbosity = 3
+	} else if c.Bool("vvvv") {
+		logger.Verbosity = 4
 	}
 }

netclient/cli_options/flags.go

@@ -198,5 +198,11 @@ func GetFlags(hostname string) []cli.Flag {
 			Value:   false,
 			Usage:   "Netclient Verbosity level 3.",
 		},
+		&cli.BoolFlag{
+			Name:    "verbosity-level-4",
+			Aliases: []string{"vvvv"},
+			Value:   false,
+			Usage:   "Netclient Verbosity level 4.",
+		},
 	}
 }

servercfg/serverconf.go

@@ -369,7 +369,7 @@ func GetVerbosity() int32 {
 	} else if config.Config.Server.Verbosity != 0 {
 		verbosity = int(config.Config.Server.Verbosity)
 	}
-	if verbosity < 0 || verbosity > 3 {
+	if verbosity < 0 || verbosity > 4 {
 		verbosity = 0
 	}
 	return int32(verbosity)