Refactor: Make errors use the parent's error level

- All wrapped errors have to be created with types.NewWrappedError to
inherit the error level from the parent
- Or types.NewWrappedErrorLevel can be used which means a custom error
level is given. For example this is done with cancelling OAuth
- Client public errors are forwarded with handleError that also logs
it with the error's level

17 files changed, 334 insertions, 474 deletions

diff --git a/client/client.go b/client/client.go
index 2808426..5df2255 100644
--- a/client/client.go
+++ b/client/client.go
@@ -19,6 +19,16 @@ type (
 	ServerBase = server.ServerBase
 )
 
+// This wraps the error, logs it and then returns the wrapped error
+func (client *Client) handleError(message string, err error) error {
+	if err != nil {
+		// Logs the error with the same level/verbosity as the error
+		client.Logger.Inherit(message, err)
+		return types.NewWrappedError(message, err)
+	}
+	return nil
+}
+
 func (client Client) isLetsConnect() bool {
 	// see https://git.sr.ht/~fkooman/vpn-user-portal/tree/v3/item/src/OAuth/ClientDb.php
 	return strings.HasPrefix(client.Name, "org.letsconnect-vpn.app")
@@ -66,10 +76,10 @@ func (client *Client) Register(
 ) error {
 	errorMessage := "failed to register with the GO library"
 	if !client.InFSMState(STATE_DEREGISTERED) {
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     FSMDeregisteredError{}.CustomError(),
-		}
+		return client.handleError(
+			errorMessage,
+			FSMDeregisteredError{}.CustomError(),
+		)
 	}
 	client.Name = name
 
@@ -84,7 +94,7 @@ func (client *Client) Register(
 
 	loggerErr := client.Logger.Init(logLevel, name, directory)
 	if loggerErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: loggerErr}
+		return client.handleError(errorMessage, loggerErr)
 	}
 
 	// Initialize the FSM
@@ -129,12 +139,7 @@ func (client *Client) Deregister() {
 	// Save the config
 	saveErr := client.Config.Save(&client)
 	if saveErr != nil {
-		client.Logger.Info(
-			fmt.Sprintf(
-				"Failed saving configuration, error: %s",
-				types.GetErrorTraceback(saveErr),
-			),
-		)
+		client.Logger.Info(fmt.Sprintf("failed saving configuration, error: %s", types.GetErrorTraceback(saveErr)))
 	}
 
 	// Empty out the state
@@ -145,7 +150,7 @@ func (client *Client) Deregister() {
 func (client *Client) askProfile(chosenServer server.Server) error {
 	base, baseErr := chosenServer.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: "failed asking for profiles", Err: baseErr}
+		return types.NewWrappedError("failed asking for profiles", baseErr)
 	}
 	client.FSM.GoTransitionWithData(STATE_ASK_PROFILE, &base.Profiles, false)
 	return nil
@@ -159,21 +164,15 @@ func (client *Client) GetDiscoOrganizations() (*types.DiscoveryOrganizations, er
 	errorMessage := "failed getting discovery organizations list"
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return nil, client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	orgs, orgsErr := client.Discovery.GetOrganizationsList()
 	if orgsErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed getting discovery organizations, Err: %s",
-				types.GetErrorTraceback(orgsErr),
-			),
+		return nil, client.handleError(
+			errorMessage,
+			orgsErr,
 		)
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     orgsErr,
-		}
 	}
 	return orgs, nil
 }
@@ -187,18 +186,15 @@ func (client *Client) GetDiscoServers() (*types.DiscoveryServers, error) {
 
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return nil, client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	servers, serversErr := client.Discovery.GetServersList()
 	if serversErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf("Failed getting discovery servers, Err: %s", types.GetErrorTraceback(serversErr)),
+		return nil, client.handleError(
+			errorMessage,
+			serversErr,
 		)
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     serversErr,
-		}
 	}
 	return servers, nil
 }
diff --git a/client/fsm.go b/client/fsm.go
index 004a3cd..a1d82f7 100644
--- a/client/fsm.go
+++ b/client/fsm.go
@@ -208,12 +208,12 @@ func newFSM(
 type FSMDeregisteredError struct{}
 
 func (e FSMDeregisteredError) CustomError() *types.WrappedErrorMessage {
-	return &types.WrappedErrorMessage{
-		Message: "Client not registered with the GO library",
-		Err: errors.New(
+	return types.NewWrappedError(
+		"Client not registered with the GO library",
+		errors.New(
 			"the current FSM state is deregistered, but the function needs a state that is not deregistered",
 		),
-	}
+	)
 }
 
 type FSMWrongStateTransitionError struct {
@@ -222,14 +222,14 @@ type FSMWrongStateTransitionError struct {
 }
 
 func (e FSMWrongStateTransitionError) CustomError() *types.WrappedErrorMessage {
-	return &types.WrappedErrorMessage{
-		Message: "Wrong FSM transition",
-		Err: fmt.Errorf(
+	return types.NewWrappedError(
+		"Wrong FSM transition",
+		fmt.Errorf(
 			"wrong FSM state, got: %s, want: a state with a transition to: %s",
 			GetStateName(e.Got),
 			GetStateName(e.Want),
 		),
-	}
+	)
 }
 
 type FSMWrongStateError struct {
@@ -238,14 +238,14 @@ type FSMWrongStateError struct {
 }
 
 func (e FSMWrongStateError) CustomError() *types.WrappedErrorMessage {
-	return &types.WrappedErrorMessage{
-		Message: "Wrong FSM State",
-		Err: fmt.Errorf(
+	return types.NewWrappedError(
+		"Wrong FSM State",
+		fmt.Errorf(
 			"wrong FSM state, got: %s, want: %s",
 			GetStateName(e.Got),
 			GetStateName(e.Want),
 		),
-	}
+	)
 }
 
 
@@ -254,19 +254,13 @@ func (e FSMWrongStateError) CustomError() *types.WrappedErrorMessage {
 // Returns an error if this state transition is not possible.
 func (client *Client) SetSearchServer() error {
 	if !client.FSM.HasTransition(STATE_SEARCH_SERVER) {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting search server, wrong state %s",
-				GetStateName(client.FSM.Current),
-			),
-		)
-		return &types.WrappedErrorMessage{
-			Message: "failed to set search server",
-			Err: FSMWrongStateTransitionError{
+		return client.handleError(
+			"failed to set search server",
+			FSMWrongStateTransitionError{
 				Got:  client.FSM.Current,
 				Want: STATE_SEARCH_SERVER,
 			}.CustomError(),
-		}
+		)
 	}
 
 	client.FSM.GoTransition(STATE_SEARCH_SERVER)
@@ -284,30 +278,18 @@ func (client *Client) SetConnected() error {
 		return nil
 	}
 	if !client.FSM.HasTransition(STATE_CONNECTED) {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting connected, wrong state: %s",
-				GetStateName(client.FSM.Current),
-			),
-		)
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: FSMWrongStateTransitionError{
+		return client.handleError(
+			errorMessage,
+			FSMWrongStateTransitionError{
 				Got:  client.FSM.Current,
 				Want: STATE_CONNECTED,
 			}.CustomError(),
-		}
+		)
 	}
 
 	currentServer, currentServerErr := client.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting connected, cannot get current server with error: %s",
-				types.GetErrorTraceback(currentServerErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+		return client.handleError(errorMessage, currentServerErr)
 	}
 
 	client.FSM.GoTransitionWithData(STATE_CONNECTED, currentServer, false)
@@ -325,30 +307,18 @@ func (client *Client) SetConnecting() error {
 		return nil
 	}
 	if !client.FSM.HasTransition(STATE_CONNECTING) {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting connecting, wrong state: %s",
-				GetStateName(client.FSM.Current),
-			),
-		)
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: FSMWrongStateTransitionError{
+		return client.handleError(
+			errorMessage,
+			FSMWrongStateTransitionError{
 				Got:  client.FSM.Current,
 				Want: STATE_CONNECTING,
 			}.CustomError(),
-		}
+		)
 	}
 
 	currentServer, currentServerErr := client.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting connecting, cannot get current server with error: %s",
-				types.GetErrorTraceback(currentServerErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+		return client.handleError(errorMessage, currentServerErr)
 	}
 
 	client.FSM.GoTransitionWithData(STATE_CONNECTING, currentServer, false)
@@ -366,30 +336,18 @@ func (client *Client) SetDisconnecting() error {
 		return nil
 	}
 	if !client.FSM.HasTransition(STATE_DISCONNECTING) {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting disconnecting, wrong state: %s",
-				GetStateName(client.FSM.Current),
-			),
-		)
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: FSMWrongStateTransitionError{
+		return client.handleError(
+			errorMessage,
+			FSMWrongStateTransitionError{
 				Got:  client.FSM.Current,
 				Want: STATE_DISCONNECTING,
 			}.CustomError(),
-		}
+		)
 	}
 
 	currentServer, currentServerErr := client.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting disconnected, cannot get current server with error: %s",
-				types.GetErrorTraceback(currentServerErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+		return client.handleError(errorMessage, currentServerErr)
 	}
 
 	client.FSM.GoTransitionWithData(STATE_DISCONNECTING, currentServer, false)
@@ -408,30 +366,18 @@ func (client *Client) SetDisconnected(cleanup bool) error {
 		return nil
 	}
 	if !client.FSM.HasTransition(STATE_DISCONNECTED) {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting disconnected, wrong state: %s",
-				GetStateName(client.FSM.Current),
-			),
-		)
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: FSMWrongStateTransitionError{
+		return client.handleError(
+			errorMessage,
+			FSMWrongStateTransitionError{
 				Got:  client.FSM.Current,
 				Want: STATE_DISCONNECTED,
 			}.CustomError(),
-		}
+		)
 	}
 
 	currentServer, currentServerErr := client.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting disconnect, failed getting current server with error: %s",
-				types.GetErrorTraceback(currentServerErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+		return client.handleError(errorMessage, currentServerErr)
 	}
 
 	if cleanup {
@@ -461,11 +407,10 @@ func (client *Client) goBackInternal() {
 func (client *Client) GoBack() error {
 	errorMessage := "failed to go back"
 	if client.InFSMState(STATE_DEREGISTERED) {
-		client.Logger.Error("Wrong state, cannot go back when deregistered")
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     FSMDeregisteredError{}.CustomError(),
-		}
+		return client.handleError(
+			errorMessage,
+			FSMDeregisteredError{}.CustomError(),
+		)
 	}
 
 	// FIXME: Abitrary back transitions don't work because we need the approriate data
@@ -479,25 +424,18 @@ func (client *Client) GoBack() error {
 func (client *Client) CancelOAuth() error {
 	errorMessage := "failed to cancel OAuth"
 	if !client.InFSMState(STATE_OAUTH_STARTED) {
-		client.Logger.Error("Failed cancelling OAuth, not in the right state")
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: FSMWrongStateError{
+		return client.handleError(
+			errorMessage,
+			FSMWrongStateError{
 				Got:  client.FSM.Current,
 				Want: STATE_OAUTH_STARTED,
 			}.CustomError(),
-		}
+		)
 	}
 
 	currentServer, serverErr := client.Servers.GetCurrentServer()
 	if serverErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed cancelling OAuth, no server configured to cancel OAuth for (err: %v)",
-				serverErr,
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return client.handleError(errorMessage, serverErr)
 	}
 	server.CancelOAuth(currentServer)
 	return nil
diff --git a/client/server.go b/client/server.go
index dfdf132..9ff895a 100644
--- a/client/server.go
+++ b/client/server.go
@@ -48,9 +48,7 @@ func (client *Client) retryConfigAuth(
 	errorMessage := "failed authorized config retry"
 	config, configType, configErr := client.getConfigAuth(chosenServer, preferTCP)
 	if configErr != nil {
-		level := types.ERR_OTHER
 		var error *oauth.OAuthTokensInvalidError
-		var oauthCancelledError *oauth.OAuthCancelledCallbackError
 
 		// Only retry if the error is that the tokens are invalid
 		if errors.As(configErr, &error) {
@@ -62,11 +60,8 @@ func (client *Client) retryConfigAuth(
 				return config, configType, nil
 			}
 		}
-		if errors.As(configErr, &oauthCancelledError) {
-			level = types.ERR_INFO
-		}
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Level: level, Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 	return config, configType, nil
 }
@@ -78,21 +73,20 @@ func (client *Client) getConfig(
 ) (string, string, error) {
 	errorMessage := "failed to get a configuration for OpenVPN/Wireguard"
 	if client.InFSMState(STATE_DEREGISTERED) {
-		return "", "", &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     FSMDeregisteredError{}.CustomError(),
-		}
+		return "", "", types.NewWrappedError(
+			errorMessage,
+			FSMDeregisteredError{}.CustomError(),
+		)
 	}
 
 	config, configType, configErr := client.retryConfigAuth(chosenServer, preferTCP)
-
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Level: types.GetErrorLevel(configErr), Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	currentServer, currentServerErr := client.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+		return "", "", types.NewWrappedError(errorMessage, currentServerErr)
 	}
 
 	// Signal the server display info
@@ -119,32 +113,19 @@ func (client *Client) SetSecureLocation(countryCode string) error {
 
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	server, serverErr := client.Discovery.GetServerByCountryCode(countryCode, "secure_internet")
 	if serverErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf(
-				"Failed getting secure internet server by country code: %s with error: %s",
-				countryCode,
-				types.GetErrorTraceback(serverErr),
-			),
-		)
 		client.goBackInternal()
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return client.handleError(errorMessage, serverErr)
 	}
 
 	setLocationErr := client.Servers.SetSecureLocation(server)
 	if setLocationErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf(
-				"Failed setting secure internet server with error: %s",
-				types.GetErrorTraceback(setLocationErr),
-			),
-		)
 		client.goBackInternal()
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: setLocationErr}
+		return client.handleError(errorMessage, setLocationErr)
 	}
 	return nil
 }
@@ -154,11 +135,10 @@ func (client *Client) SetSecureLocation(countryCode string) error {
 // Note that if the server does not exist, it returns nil as an error.
 func (client *Client) RemoveSecureInternet() error {
 	if client.InFSMState(STATE_DEREGISTERED) {
-		client.Logger.Error("Failed removing secure internet server due to deregistered")
-		return &types.WrappedErrorMessage{
-			Message: "failed to remove Secure Internet",
-			Err:     FSMDeregisteredError{}.CustomError(),
-		}
+		return client.handleError(
+			"failed to remove Secure Internet",
+			FSMDeregisteredError{}.CustomError(),
+		)
 	}
 	// No error because we can only have one secure internet server and if there are no secure internet servers, this is a NO-OP
 	client.Servers.RemoveSecureInternet()
@@ -181,10 +161,10 @@ func (client *Client) RemoveSecureInternet() error {
 // Note that if the server does not exist, it returns nil as an error.
 func (client *Client) RemoveInstituteAccess(url string) error {
 	if client.InFSMState(STATE_DEREGISTERED) {
-		return &types.WrappedErrorMessage{
-			Message: "failed to remove Institute Access",
-			Err:     FSMDeregisteredError{}.CustomError(),
-		}
+		return client.handleError(
+			"failed to remove Institute Access",
+			FSMDeregisteredError{}.CustomError(),
+		)
 	}
 	// No error because this is a NO-OP if the server doesn't exist
 	client.Servers.RemoveInstituteAccess(url)
@@ -207,10 +187,10 @@ func (client *Client) RemoveInstituteAccess(url string) error {
 // Note that if the server does not exist, it returns nil as an error.
 func (client *Client) RemoveCustomServer(url string) error {
 	if client.InFSMState(STATE_DEREGISTERED) {
-		return &types.WrappedErrorMessage{
-			Message: "failed to remove Custom Server",
-			Err:     FSMDeregisteredError{}.CustomError(),
-		}
+		return client.handleError(
+			"failed to remove Custom Server",
+			FSMDeregisteredError{}.CustomError(),
+		)
 	}
 	// No error because this is a NO-OP if the server doesn't exist
 	client.Servers.RemoveCustomServer(url)
@@ -234,7 +214,7 @@ func (client *Client) AddInstituteServer(url string) (server.Server, error) {
 
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return nil, client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	// Indicate that we're loading the server
@@ -245,21 +225,21 @@ func (client *Client) AddInstituteServer(url string) (server.Server, error) {
 	instituteServer, discoErr := client.Discovery.GetServerByURL(url, "institute_access")
 	if discoErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: discoErr}
+		return nil, client.handleError(errorMessage, discoErr)
 	}
 
 	// Add the secure internet server
 	server, serverErr := client.Servers.AddInstituteAccessServer(instituteServer)
 	if serverErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return nil, client.handleError(errorMessage, serverErr)
 	}
 
 	// Set the server as the current so OAuth can be cancelled
 	currentErr := client.Servers.SetInstituteAccess(server)
 	if currentErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: currentErr}
+		return nil, client.handleError(errorMessage, currentErr)
 	}
 
 	// Indicate that we want to authorize this server
@@ -270,7 +250,7 @@ func (client *Client) AddInstituteServer(url string) (server.Server, error) {
 	if loginErr != nil {
 		// Removing is best effort
 		_ = client.RemoveInstituteAccess(url)
-		return nil, &types.WrappedErrorMessage{Level: types.GetErrorLevel(loginErr), Message: errorMessage, Err: loginErr}
+		return nil, client.handleError(errorMessage, loginErr)
 	}
 
 	client.FSM.GoTransitionWithData(STATE_NO_SERVER, client.Servers, false)
@@ -287,7 +267,7 @@ func (client *Client) AddSecureInternetHomeServer(orgID string) (server.Server,
 
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return nil, client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	// Indicate that we're loading the server
@@ -297,14 +277,14 @@ func (client *Client) AddSecureInternetHomeServer(orgID string) (server.Server,
 	secureOrg, secureServer, discoErr := client.Discovery.GetSecureHomeArgs(orgID)
 	if discoErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: discoErr}
+		return nil, client.handleError(errorMessage, discoErr)
 	}
 
 	// Add the secure internet server
 	server, serverErr := client.Servers.AddSecureInternet(secureOrg, secureServer)
 	if serverErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return nil, client.handleError(errorMessage, serverErr)
 	}
 
 	locationErr := client.askSecureLocation()
@@ -312,14 +292,14 @@ func (client *Client) AddSecureInternetHomeServer(orgID string) (server.Server,
 		// Removing is best effort
 		// This already goes back to the main screen
 		_ = client.RemoveSecureInternet()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: locationErr}
+		return nil, client.handleError(errorMessage, locationErr)
 	}
 
 	// Set the server as the current so OAuth can be cancelled
 	currentErr := client.Servers.SetSecureInternet(server)
 	if currentErr != nil {
 		client.goBackInternal()
-		return nil,  &types.WrappedErrorMessage{Message: errorMessage, Err: currentErr}
+		return nil,  client.handleError(errorMessage, currentErr)
 	}
 
 	// Server has been chosen for authentication
@@ -330,7 +310,7 @@ func (client *Client) AddSecureInternetHomeServer(orgID string) (server.Server,
 	if loginErr != nil {
 		// Removing is best effort
 		_ = client.RemoveSecureInternet()
-		return nil, &types.WrappedErrorMessage{Level: types.GetErrorLevel(loginErr), Message: errorMessage, Err: loginErr}
+		return nil, client.handleError(errorMessage, loginErr)
 	}
 	client.FSM.GoTransitionWithData(STATE_NO_SERVER, client.Servers, false)
 	return server, nil
@@ -342,7 +322,7 @@ func (client *Client) AddCustomServer(url string) (server.Server, error) {
 
 	url, urlErr := util.EnsureValidURL(url)
 	if urlErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return nil, client.handleError(errorMessage, urlErr)
 	}
 
 	// Indicate that we're loading the server
@@ -358,14 +338,14 @@ func (client *Client) AddCustomServer(url string) (server.Server, error) {
 	server, serverErr := client.Servers.AddCustomServer(customServer)
 	if serverErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return nil, client.handleError(errorMessage, serverErr)
 	}
 
 	// Set the server as the current so OAuth can be cancelled
 	currentErr := client.Servers.SetCustomServer(server)
 	if currentErr != nil {
 		client.goBackInternal()
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: currentErr}
+		return nil, client.handleError(errorMessage, currentErr)
 	}
 
 	// Server has been chosen for authentication
@@ -376,7 +356,7 @@ func (client *Client) AddCustomServer(url string) (server.Server, error) {
 	if loginErr != nil {
 		// removing is best effort
 		_ = client.RemoveCustomServer(url)
-		return nil, &types.WrappedErrorMessage{Level: types.GetErrorLevel(loginErr), Message: errorMessage, Err: loginErr}
+		return nil, client.handleError(errorMessage, loginErr)
 	}
 
 	client.FSM.GoTransitionWithData(STATE_NO_SERVER, client.Servers, false)
@@ -391,7 +371,7 @@ func (client *Client) GetConfigInstituteAccess(url string, preferTCP bool) (stri
 
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return "", "", client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	client.FSM.GoTransition(STATE_LOADING_SERVER)
@@ -399,20 +379,14 @@ func (client *Client) GetConfigInstituteAccess(url string, preferTCP bool) (stri
 	// Get the server if it exists
 	server, serverErr := client.Servers.GetInstituteAccess(url)
 	if serverErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf(
-				"Failed getting an institute access server configuration with error: %s",
-				types.GetErrorTraceback(serverErr),
-			),
-		)
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return "", "", client.handleError(errorMessage, serverErr)
 	}
 
 	// Set the server as the current
 	currentErr := client.Servers.SetInstituteAccess(server)
 	if currentErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: currentErr}
+		return "", "", client.handleError(errorMessage, currentErr)
 	}
 
 	// The server has now been chosen
@@ -420,14 +394,8 @@ func (client *Client) GetConfigInstituteAccess(url string, preferTCP bool) (stri
 
 	config, configType, configErr := client.getConfig(server, preferTCP)
 	if configErr != nil {
-		client.Logger.Inherit(configErr,
-			fmt.Sprintf(
-				"Failed getting an institute access server configuration with error: %s",
-				types.GetErrorTraceback(configErr),
-			),
-		)
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Level: types.GetErrorLevel(configErr), Message: errorMessage, Err: configErr}
+		return "", "", client.handleError(errorMessage, configErr)
 	}
 	return config, configType, nil
 }
@@ -446,7 +414,7 @@ func (client *Client) GetConfigSecureInternet(
 
 	// Not supported with Let's Connect!
 	if client.isLetsConnect() {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: LetsConnectNotSupportedError{}}
+		return "", "", client.handleError(errorMessage, LetsConnectNotSupportedError{})
 	}
 
 	client.FSM.GoTransition(STATE_LOADING_SERVER)
@@ -454,35 +422,22 @@ func (client *Client) GetConfigSecureInternet(
 	// Get the server if it exists
 	server, serverErr := client.Servers.GetSecureInternetHomeServer()
 	if serverErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf(
-				"Failed getting a custom server configuration with error: %s",
-				types.GetErrorTraceback(serverErr),
-			),
-		)
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return "", "", client.handleError(errorMessage, serverErr)
 	}
 
 	// Set the server as the current
 	currentErr := client.Servers.SetSecureInternet(server)
 	if currentErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: currentErr}
+		return "", "", client.handleError(errorMessage, currentErr)
 	}
 
 	client.FSM.GoTransition(STATE_CHOSEN_SERVER)
 
 	config, configType, configErr := client.getConfig(server, preferTCP)
 	if configErr != nil {
-		client.Logger.Inherit(
-			configErr,
-			fmt.Sprintf(
-				"Failed getting a secure internet configuration with error: %s",
-				types.GetErrorTraceback(configErr),
-			),
-		)
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Level: types.GetErrorLevel(configErr), Message: errorMessage, Err: configErr}
+		return "", "", client.handleError(errorMessage, configErr)
 	}
 	return config, configType, nil
 }
@@ -495,7 +450,7 @@ func (client *Client) GetConfigCustomServer(url string, preferTCP bool) (string,
 
 	url, urlErr := util.EnsureValidURL(url)
 	if urlErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return "", "", client.handleError(errorMessage, urlErr)
 	}
 
 	client.FSM.GoTransition(STATE_LOADING_SERVER)
@@ -503,35 +458,22 @@ func (client *Client) GetConfigCustomServer(url string, preferTCP bool) (string,
 	// Get the server if it exists
 	server, serverErr := client.Servers.GetCustomServer(url)
 	if serverErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf(
-				"Failed getting a custom server configuration with error: %s",
-				types.GetErrorTraceback(serverErr),
-			),
-		)
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return "", "", client.handleError(errorMessage, serverErr)
 	}
 
 	// Set the server as the current
 	currentErr := client.Servers.SetCustomServer(server)
 	if currentErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: currentErr}
+		return "", "", client.handleError(errorMessage, currentErr)
 	}
 
 	client.FSM.GoTransition(STATE_CHOSEN_SERVER)
 
 	config, configType, configErr := client.getConfig(server, preferTCP)
 	if configErr != nil {
-		client.Logger.Inherit(
-			configErr,
-			fmt.Sprintf(
-				"Failed getting a custom server with error: %s",
-				types.GetErrorTraceback(configErr),
-			),
-		)
 		client.goBackInternal()
-		return "", "", &types.WrappedErrorMessage{Level: types.GetErrorLevel(configErr), Message: errorMessage, Err: configErr}
+		return "", "", client.handleError(errorMessage, configErr)
 	}
 	return config, configType, nil
 }
@@ -546,10 +488,10 @@ func (client *Client) askSecureLocation() error {
 	// The state has changed, meaning setting the secure location was not successful
 	if client.FSM.Current != STATE_ASK_LOCATION {
 		// TODO: maybe a custom type for this errors.new?
-		return &types.WrappedErrorMessage{
-			Message: "failed setting secure location",
-			Err:     errors.New("failed loading secure location"),
-		}
+		return types.NewWrappedError(
+			"failed setting secure location",
+			errors.New("failed loading secure location"),
+		)
 	}
 	return nil
 }
@@ -561,25 +503,18 @@ func (client *Client) ChangeSecureLocation() error {
 	errorMessage := "failed to change location from the main screen"
 
 	if !client.InFSMState(STATE_NO_SERVER) {
-		client.Logger.Error("Failed changing secure internet location, not in the right state")
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: FSMWrongStateError{
+		return client.handleError(
+			errorMessage,
+			FSMWrongStateError{
 				Got:  client.FSM.Current,
 				Want: STATE_NO_SERVER,
 			}.CustomError(),
-		}
+		)
 	}
 
 	askLocationErr := client.askSecureLocation()
 	if askLocationErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf(
-				"Failed changing secure internet location, err: %s",
-				types.GetErrorTraceback(askLocationErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: askLocationErr}
+		return client.handleError(errorMessage, askLocationErr)
 	}
 
 	// Go back to the main screen
@@ -596,25 +531,13 @@ func (client *Client) RenewSession() error {
 
 	currentServer, currentServerErr := client.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed getting current server to renew, error: %s",
-				types.GetErrorTraceback(currentServerErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+		return client.handleError(errorMessage, currentServerErr)
 	}
 
 	server.MarkTokensForRenew(currentServer)
 	loginErr := client.ensureLogin(currentServer)
 	if loginErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed logging in server for renew, error: %s",
-				types.GetErrorTraceback(loginErr),
-			),
-		)
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: loginErr}
+		return client.handleError(errorMessage, loginErr)
 	}
 
 	return nil
@@ -658,14 +581,14 @@ func (client *Client) ensureLogin(chosenServer server.Server) error {
 
 		if urlErr != nil {
 			client.goBackInternal()
-			return &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+			return types.NewWrappedError(errorMessage, urlErr)
 		}
 
 		exchangeErr := server.OAuthExchange(chosenServer)
 
 		if exchangeErr != nil {
 			client.goBackInternal()
-			return &types.WrappedErrorMessage{Message: errorMessage, Err: exchangeErr}
+			return types.NewWrappedError(errorMessage, exchangeErr)
 		}
 	}
 	// OAuth was valid, ensure we are in the authorized state
@@ -679,23 +602,14 @@ func (client *Client) SetProfileID(profileID string) error {
 	errorMessage := "failed to set the profile ID for the current server"
 	server, serverErr := client.Servers.GetCurrentServer()
 	if serverErr != nil {
-		client.Logger.Warning(
-			fmt.Sprintf(
-				"Failed setting a profile ID because no server configured, Err: %s",
-				types.GetErrorTraceback(serverErr),
-			),
-		)
 		client.goBackInternal()
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return client.handleError(errorMessage, serverErr)
 	}
 
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		client.Logger.Error(
-			fmt.Sprintf("Failed setting a profile ID, Err: %s", types.GetErrorTraceback(serverErr)),
-		)
 		client.goBackInternal()
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return client.handleError(errorMessage, baseErr)
 	}
 	base.Profiles.Current = profileID
 	return nil
diff --git a/internal/config/config.go b/internal/config/config.go
index 1d5a201..180b881 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -29,11 +29,11 @@ func (config *Config) Save(readStruct interface{}) error {
 	errorMessage := "failed saving configuration"
 	configDirErr := util.EnsureDirectory(config.Directory)
 	if configDirErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: configDirErr}
+		return types.NewWrappedError(errorMessage, configDirErr)
 	}
 	jsonString, marshalErr := json.Marshal(readStruct)
 	if marshalErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: marshalErr}
+		return types.NewWrappedError(errorMessage, marshalErr)
 	}
 	return ioutil.WriteFile(config.GetFilename(), jsonString, 0o600)
 }
@@ -41,7 +41,7 @@ func (config *Config) Save(readStruct interface{}) error {
 func (config *Config) Load(writeStruct interface{}) error {
 	bytes, readErr := ioutil.ReadFile(config.GetFilename())
 	if readErr != nil {
-		return &types.WrappedErrorMessage{Message: "failed loading configuration", Err: readErr}
+		return types.NewWrappedError("failed loading configuration", readErr)
 	}
 	return json.Unmarshal(bytes, writeStruct)
 }
diff --git a/internal/discovery/discovery.go b/internal/discovery/discovery.go
index 01773fa..d639406 100644
--- a/internal/discovery/discovery.go
+++ b/internal/discovery/discovery.go
@@ -25,7 +25,7 @@ func getDiscoFile(jsonFile string, previousVersion uint64, structure interface{}
 	_, fileBody, fileErr := http.HTTPGet(fileURL)
 
 	if fileErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: fileErr}
+		return types.NewWrappedError(errorMessage, fileErr)
 	}
 
 	// Get signature
@@ -34,7 +34,7 @@ func getDiscoFile(jsonFile string, previousVersion uint64, structure interface{}
 	_, sigBody, sigFileErr := http.HTTPGet(sigURL)
 
 	if sigFileErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: sigFileErr}
+		return types.NewWrappedError(errorMessage, sigFileErr)
 	}
 
 	// Verify signature
@@ -49,14 +49,14 @@ func getDiscoFile(jsonFile string, previousVersion uint64, structure interface{}
 	)
 
 	if !verifySuccess || verifyErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: verifyErr}
+		return types.NewWrappedError(errorMessage, verifyErr)
 	}
 
 	// Parse JSON to extract version and list
 	jsonErr := json.Unmarshal(fileBody, structure)
 
 	if jsonErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: jsonErr}
+		return types.NewWrappedError(errorMessage, jsonErr)
 	}
 
 	return nil
@@ -91,10 +91,10 @@ func (discovery *Discovery) GetServerByURL(
 			return &server, nil
 		}
 	}
-	return nil, &types.WrappedErrorMessage{
-		Message: "failed getting server by URL from discovery",
-		Err:     &GetServerByURLNotFoundError{URL: url, Type: _type},
-	}
+	return nil, types.NewWrappedError(
+		"failed getting server by URL from discovery",
+		&GetServerByURLNotFoundError{URL: url, Type: _type},
+	)
 }
 
 func (discovery *Discovery) GetServerByCountryCode(
@@ -106,10 +106,10 @@ func (discovery *Discovery) GetServerByCountryCode(
 			return &server, nil
 		}
 	}
-	return nil, &types.WrappedErrorMessage{
-		Message: "failed getting server by country code from discovery",
-		Err:     &GetServerByCountryCodeNotFoundError{CountryCode: code, Type: _type},
-	}
+	return nil, types.NewWrappedError(
+		"failed getting server by country code from discovery",
+		&GetServerByCountryCodeNotFoundError{CountryCode: code, Type: _type},
+	)
 }
 
 func (discovery *Discovery) getOrgByID(orgID string) (*types.DiscoveryOrganization, error) {
@@ -118,10 +118,10 @@ func (discovery *Discovery) getOrgByID(orgID string) (*types.DiscoveryOrganizati
 			return &organization, nil
 		}
 	}
-	return nil, &types.WrappedErrorMessage{
-		Message: "failed getting Secure Internet Home URL from discovery",
-		Err:     &GetOrgByIDNotFoundError{ID: orgID},
-	}
+	return nil, types.NewWrappedError(
+		"failed getting Secure Internet Home URL from discovery",
+		&GetOrgByIDNotFoundError{ID: orgID},
+	)
 }
 
 func (discovery *Discovery) GetSecureHomeArgs(
@@ -131,7 +131,7 @@ func (discovery *Discovery) GetSecureHomeArgs(
 	org, orgErr := discovery.getOrgByID(orgID)
 
 	if orgErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: orgErr}
+		return nil, nil, types.NewWrappedError(errorMessage, orgErr)
 	}
 
 	// Get a server with the base url
@@ -140,7 +140,7 @@ func (discovery *Discovery) GetSecureHomeArgs(
 	server, serverErr := discovery.GetServerByURL(url, "secure_internet")
 
 	if serverErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
+		return nil, nil, types.NewWrappedError(errorMessage, serverErr)
 	}
 	return org, server, nil
 }
@@ -168,10 +168,10 @@ func (discovery *Discovery) GetOrganizationsList() (*types.DiscoveryOrganization
 	bodyErr := getDiscoFile(file, discovery.Organizations.Version, &discovery.Organizations)
 	if bodyErr != nil {
 		// Return previous with an error
-		return &discovery.Organizations, &types.WrappedErrorMessage{
-			Message: "failed getting organizations in Discovery",
-			Err:     bodyErr,
-		}
+		return &discovery.Organizations, types.NewWrappedError(
+			"failed getting organizations in Discovery",
+			bodyErr,
+		)
 	}
 	discovery.Organizations.Timestamp = util.GetCurrentTime()
 	return &discovery.Organizations, nil
@@ -186,10 +186,10 @@ func (discovery *Discovery) GetServersList() (*types.DiscoveryServers, error) {
 	bodyErr := getDiscoFile(file, discovery.Servers.Version, &discovery.Servers)
 	if bodyErr != nil {
 		// Return previous with an error
-		return &discovery.Servers, &types.WrappedErrorMessage{
-			Message: "failed getting servers in Discovery",
-			Err:     bodyErr,
-		}
+		return &discovery.Servers, types.NewWrappedError(
+			"failed getting servers in Discovery",
+			bodyErr,
+		)
 	}
 	// Update servers timestamp
 	discovery.Servers.Timestamp = util.GetCurrentTime()
diff --git a/internal/http/http.go b/internal/http/http.go
index 02d83a6..6ff853b 100644
--- a/internal/http/http.go
+++ b/internal/http/http.go
@@ -25,14 +25,14 @@ type HTTPOptionalParams struct {
 func HTTPConstructURL(baseURL string, parameters URLParameters) (string, error) {
 	url, parseErr := url.Parse(baseURL)
 	if parseErr != nil {
-		return "", &types.WrappedErrorMessage{
-			Message: fmt.Sprintf(
+		return "", types.NewWrappedError(
+			fmt.Sprintf(
 				"failed to construct url: %s including parameters: %v",
 				url,
 				parameters,
 			),
-			Err: parseErr,
-		}
+			parseErr,
+		)
 	}
 
 	q := url.Query()
@@ -66,10 +66,10 @@ func httpOptionalURL(url string, opts *HTTPOptionalParams) (string, error) {
 		url, urlErr := HTTPConstructURL(url, opts.URLParameters)
 
 		if urlErr != nil {
-			return url, &types.WrappedErrorMessage{
-				Message: fmt.Sprintf("failed to create HTTP request with url: %s", url),
-				Err:     urlErr,
-			}
+			return url, types.NewWrappedError(
+				fmt.Sprintf("failed to create HTTP request with url: %s", url),
+				urlErr,
+			)
 		}
 		return url, nil
 	}
@@ -121,7 +121,7 @@ func HTTPMethodWithOpts(
 	// Create request object with the body reader generated from the optional arguments
 	req, reqErr := http.NewRequest(method, url, httpOptionalBodyReader(opts))
 	if reqErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: reqErr}
+		return nil, nil, types.NewWrappedError(errorMessage, reqErr)
 	}
 
 	// See https://stackoverflow.com/questions/17714494/golang-http-request-results-in-eof-errors-when-making-multiple-requests-successi
@@ -133,7 +133,7 @@ func HTTPMethodWithOpts(
 	// Do request
 	resp, respErr := client.Do(req)
 	if respErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: respErr}
+		return nil, nil, types.NewWrappedError(errorMessage, respErr)
 	}
 
 	// Request successful, make sure body is closed at the end
@@ -142,13 +142,13 @@ func HTTPMethodWithOpts(
 	// Return a string
 	body, readErr := ioutil.ReadAll(resp.Body)
 	if readErr != nil {
-		return resp.Header, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: readErr}
+		return resp.Header, nil, types.NewWrappedError(errorMessage, readErr)
 	}
 
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
 		// We make this a custom error because we want to extract the status code later
 		statusErr := &HTTPStatusError{URL: url, Body: string(body), Status: resp.StatusCode}
-		return resp.Header, body, &types.WrappedErrorMessage{Message: errorMessage, Err: statusErr}
+		return resp.Header, body, types.NewWrappedError(errorMessage, statusErr)
 	}
 
 	// Return the body in bytes and signal the status error if there was one
diff --git a/internal/log/log.go b/internal/log/log.go
index 970480f..eabecb9 100644
--- a/internal/log/log.go
+++ b/internal/log/log.go
@@ -52,7 +52,7 @@ func (logger *FileLogger) Init(level LogLevel, name string, directory string) er
 
 	configDirErr := util.EnsureDirectory(directory)
 	if configDirErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: configDirErr}
+		return types.NewWrappedError(errorMessage, configDirErr)
 	}
 	logFile, logOpenErr := os.OpenFile(
 		logger.getFilename(directory, name),
@@ -60,7 +60,7 @@ func (logger *FileLogger) Init(level LogLevel, name string, directory string) er
 		0o666,
 	)
 	if logOpenErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: logOpenErr}
+		return types.NewWrappedError(errorMessage, logOpenErr)
 	}
 	log.SetOutput(logFile)
 	logger.File = logFile
@@ -68,9 +68,10 @@ func (logger *FileLogger) Init(level LogLevel, name string, directory string) er
 	return nil
 }
 
-func (logger *FileLogger) Inherit(err error, msg string) {
+func (logger *FileLogger) Inherit(label string, err error) {
 	level := types.GetErrorLevel(err)
 
+	msg := fmt.Sprintf("%s with err: %s", label, types.GetErrorTraceback(err))
 	switch level {
 	case types.ERR_INFO:
 		logger.Info(msg)
diff --git a/internal/oauth/oauth.go b/internal/oauth/oauth.go
index 6ac773c..df29a9c 100644
--- a/internal/oauth/oauth.go
+++ b/internal/oauth/oauth.go
@@ -28,7 +28,7 @@ import (
 func genState() (string, error) {
 	randomBytes, err := util.MakeRandomByteSlice(32)
 	if err != nil {
-		return "", &types.WrappedErrorMessage{Message: "failed generating an OAuth state", Err: err}
+		return "", types.NewWrappedError("failed generating an OAuth state", err)
 	}
 
 	// For consistency we also use raw url encoding here
@@ -61,10 +61,10 @@ func genChallengeS256(verifier string) string {
 func genVerifier() (string, error) {
 	randomBytes, err := util.MakeRandomByteSlice(32)
 	if err != nil {
-		return "", &types.WrappedErrorMessage{
-			Message: "failed generating an OAuth verifier",
-			Err:     err,
-		}
+		return "", types.NewWrappedError(
+			"failed generating an OAuth verifier",
+			err,
+		)
 	}
 
 	return base64.RawURLEncoding.EncodeToString(randomBytes), nil
@@ -111,7 +111,7 @@ func (oauth *OAuth) setupListener() error {
 	// create a listener
 	listener, listenerErr := net.Listen("tcp", ":0")
 	if listenerErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: listenerErr}
+		return types.NewWrappedError(errorMessage, listenerErr)
 	}
 	oauth.Session.Listener = listener
 	return nil
@@ -120,7 +120,7 @@ func (oauth *OAuth) setupListener() error {
 func (oauth *OAuth) getTokensWithCallback() error {
 	errorMessage := "failed getting tokens with callback"
 	if oauth.Session.Listener == nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("No listener")}
+		return types.NewWrappedError(errorMessage, errors.New("No listener"))
 	}
 	mux := http.NewServeMux()
 	// server /callback over the listener address
@@ -130,7 +130,7 @@ func (oauth *OAuth) getTokensWithCallback() error {
 	mux.HandleFunc("/callback", oauth.Callback)
 
 	if err := oauth.Session.Server.Serve(oauth.Session.Listener); err != http.ErrServerClosed {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: err}
+		return types.NewWrappedError(errorMessage, err)
 	}
 	return oauth.Session.CallbackError
 }
@@ -146,7 +146,7 @@ func (oauth *OAuth) getTokensWithAuthCode(authCode string) error {
 
 	port, portErr := oauth.GetListenerPort()
 	if portErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: portErr}
+		return types.NewWrappedError(errorMessage, portErr)
 	}
 
 	data := url.Values{
@@ -163,7 +163,7 @@ func (oauth *OAuth) getTokensWithAuthCode(authCode string) error {
 	current_time := util.GetCurrentTime()
 	_, body, bodyErr := httpw.HTTPPostWithOpts(reqURL, opts)
 	if bodyErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return types.NewWrappedError(errorMessage, bodyErr)
 	}
 
 	tokenStructure := OAuthToken{}
@@ -171,10 +171,10 @@ func (oauth *OAuth) getTokensWithAuthCode(authCode string) error {
 	jsonErr := json.Unmarshal(body, &tokenStructure)
 
 	if jsonErr != nil {
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &httpw.HTTPParseJsonError{URL: reqURL, Body: string(body), Err: jsonErr},
-		}
+		return types.NewWrappedError(
+			errorMessage,
+			&httpw.HTTPParseJsonError{URL: reqURL, Body: string(body), Err: jsonErr},
+		)
 	}
 
 	tokenStructure.ExpiredTimestamp = current_time.Add(
@@ -207,17 +207,17 @@ func (oauth *OAuth) getTokensWithRefresh() error {
 	current_time := util.GetCurrentTime()
 	_, body, bodyErr := httpw.HTTPPostWithOpts(reqURL, opts)
 	if bodyErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return types.NewWrappedError(errorMessage, bodyErr)
 	}
 
 	tokenStructure := OAuthToken{}
 	jsonErr := json.Unmarshal(body, &tokenStructure)
 
 	if jsonErr != nil {
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &httpw.HTTPParseJsonError{URL: reqURL, Body: string(body), Err: jsonErr},
-		}
+		return types.NewWrappedError(
+			errorMessage,
+			&httpw.HTTPParseJsonError{URL: reqURL, Body: string(body), Err: jsonErr},
+		)
 	}
 
 	tokenStructure.ExpiredTimestamp = current_time.Add(
@@ -273,7 +273,7 @@ func writeResponseHTML(w http.ResponseWriter, title string, message string) erro
 	errorMessage := "failed writing response HTML"
 	template, templateErr := template.New("oauth-response").Parse(responseTemplate)
 	if templateErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: templateErr}
+		return types.NewWrappedError(errorMessage, templateErr)
 	}
 
 	executeErr := template.Execute(w, oauthResponseHTML{
@@ -281,7 +281,7 @@ func writeResponseHTML(w http.ResponseWriter, title string, message string) erro
 		Message: message,
 	})
 	if executeErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: executeErr}
+		return types.NewWrappedError(errorMessage, executeErr)
 	}
 	return nil
 }
@@ -310,10 +310,10 @@ func (oauth *OAuth) Callback(w http.ResponseWriter, req *http.Request) {
 	extractedISS := urlQuery.Get("iss")
 	if extractedISS != "" {
 		if oauth.Session.ISS != extractedISS {
-			oauth.Session.CallbackError = &types.WrappedErrorMessage{
-				Message: errorMessage,
-				Err:     &OAuthCallbackISSMatchError{ISS: extractedISS, ExpectedISS: oauth.Session.ISS},
-			}
+			oauth.Session.CallbackError = types.NewWrappedError(
+				errorMessage,
+				&OAuthCallbackISSMatchError{ISS: extractedISS, ExpectedISS: oauth.Session.ISS},
+			)
 			return
 		}
 
@@ -323,31 +323,31 @@ func (oauth *OAuth) Callback(w http.ResponseWriter, req *http.Request) {
 	// https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-04#section-7.15
 	extractedState := urlQuery.Get("state")
 	if extractedState == "" {
-		oauth.Session.CallbackError = &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &OAuthCallbackParameterError{Parameter: "state", URL: req.URL.String()},
-		}
+		oauth.Session.CallbackError = types.NewWrappedError(
+			errorMessage,
+			&OAuthCallbackParameterError{Parameter: "state", URL: req.URL.String()},
+		)
 		return
 	}
 	// The state is the first entry
 	if extractedState != oauth.Session.State {
-		oauth.Session.CallbackError = &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: &OAuthCallbackStateMatchError{
+		oauth.Session.CallbackError = types.NewWrappedError(
+			errorMessage,
+			&OAuthCallbackStateMatchError{
 				State:         extractedState,
 				ExpectedState: oauth.Session.State,
 			},
-		}
+		)
 		return
 	}
 
 	// No authorization code
 	extractedCode := urlQuery.Get("code")
 	if extractedCode == "" {
-		oauth.Session.CallbackError = &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &OAuthCallbackParameterError{Parameter: "code", URL: req.URL.String()},
-		}
+		oauth.Session.CallbackError = types.NewWrappedError(
+			errorMessage,
+			&OAuthCallbackParameterError{Parameter: "code", URL: req.URL.String()},
+		)
 		return
 	}
 
@@ -355,10 +355,10 @@ func (oauth *OAuth) Callback(w http.ResponseWriter, req *http.Request) {
 	// Obtaining the access and refresh tokens
 	getTokensErr := oauth.getTokensWithAuthCode(extractedCode)
 	if getTokensErr != nil {
-		oauth.Session.CallbackError = &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     getTokensErr,
-		}
+		oauth.Session.CallbackError = types.NewWrappedError(
+			errorMessage,
+			getTokensErr,
+		)
 		return
 	}
 }
@@ -372,7 +372,7 @@ func (oauth OAuth) GetListenerPort() (int, error) {
 	errorMessage := "failed to get listener port"
 
 	if oauth.Session.Listener == nil {
-		return 0, &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("No OAuth listener")}
+		return 0, types.NewWrappedError(errorMessage, errors.New("No OAuth listener"))
 	}
 	return oauth.Session.Listener.Addr().(*net.TCPAddr).Port, nil
 }
@@ -384,14 +384,14 @@ func (oauth *OAuth) GetAuthURL(name string, iss string, postProcessAuth func(str
 	// Generate the verifier and challenge
 	verifier, verifierErr := genVerifier()
 	if verifierErr != nil {
-		return "", &types.WrappedErrorMessage{Message: errorMessage, Err: verifierErr}
+		return "", types.NewWrappedError(errorMessage, verifierErr)
 	}
 	challenge := genChallengeS256(verifier)
 
 	// Generate the state
 	state, stateErr := genState()
 	if stateErr != nil {
-		return "", &types.WrappedErrorMessage{Message: errorMessage, Err: stateErr}
+		return "", types.NewWrappedError(errorMessage, stateErr)
 	}
 
 	// Fill the struct with the necessary fields filled for the next call to getting the HTTP client
@@ -401,13 +401,13 @@ func (oauth *OAuth) GetAuthURL(name string, iss string, postProcessAuth func(str
 	// set up the listener to get the redirect URI
 	listenerErr := oauth.setupListener()
 	if listenerErr != nil {
-		return "", &types.WrappedErrorMessage{Message: errorMessage, Err: stateErr}
+		return "", types.NewWrappedError(errorMessage, stateErr)
 	}
 
 	// Get the listener port
 	port, portErr := oauth.GetListenerPort()
 	if portErr != nil {
-		return "", &types.WrappedErrorMessage{Message: errorMessage, Err: portErr}
+		return "", types.NewWrappedError(errorMessage, portErr)
 	}
 
 	parameters := map[string]string{
@@ -423,7 +423,7 @@ func (oauth *OAuth) GetAuthURL(name string, iss string, postProcessAuth func(str
 	authURL, urlErr := httpw.HTTPConstructURL(oauth.BaseAuthorizationURL, parameters)
 
 	if urlErr != nil {
-		return "", &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return "", types.NewWrappedError(errorMessage, urlErr)
 	}
 
 	// Return the url processed
@@ -435,16 +435,17 @@ func (oauth *OAuth) Exchange() error {
 	tokenErr := oauth.getTokensWithCallback()
 
 	if tokenErr != nil {
-		return &types.WrappedErrorMessage{Message: "failed finishing OAuth", Err: tokenErr}
+		return types.NewWrappedError("failed finishing OAuth", tokenErr)
 	}
 	return nil
 }
 
 func (oauth *OAuth) Cancel() {
-	oauth.Session.CallbackError = &types.WrappedErrorMessage{
-		Message: "cancelled OAuth",
-		Err:     &OAuthCancelledCallbackError{},
-	}
+	oauth.Session.CallbackError = types.NewWrappedErrorLevel(
+		types.ERR_INFO,
+		"cancelled OAuth",
+		&OAuthCancelledCallbackError{},
+	)
 	if oauth.Session.Server != nil {
 		oauth.Session.Server.Shutdown(oauth.Session.Context) //nolint:errcheck
 	}
@@ -454,10 +455,10 @@ func (oauth *OAuth) EnsureTokens() error {
 	errorMessage := "failed ensuring OAuth tokens"
 	// Access Token or Refresh Tokens empty, we can not ensure the tokens
 	if oauth.Token.Access == "" && oauth.Token.Refresh == "" {
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &OAuthTokensInvalidError{Cause: "tokens are empty"},
-		}
+		return types.NewWrappedError(
+			errorMessage,
+			&OAuthTokensInvalidError{Cause: "tokens are empty"},
+		)
 	}
 
 	// We have tokens...
@@ -472,12 +473,12 @@ func (oauth *OAuth) EnsureTokens() error {
 	// We have obtained new tokens with refresh
 	if refreshErr != nil {
 		// We have failed to ensure the tokens due to refresh not working
-		return &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err: &OAuthTokensInvalidError{
+		return types.NewWrappedError(
+			errorMessage,
+			&OAuthTokensInvalidError{
 				Cause: fmt.Sprintf("tokens failed refresh with error: %v", refreshErr),
 			},
-		}
+		)
 	}
 
 	return nil
diff --git a/internal/server/api.go b/internal/server/api.go
index 05d2528..be7281c 100644
--- a/internal/server/api.go
+++ b/internal/server/api.go
@@ -17,21 +17,21 @@ func APIGetEndpoints(baseURL string) (*ServerEndpoints, error) {
 	errorMessage := "failed getting server endpoints"
 	url, urlErr := url.Parse(baseURL)
 	if urlErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return nil, types.NewWrappedError(errorMessage, urlErr)
 	}
 
 	url.Path = path.Join(url.Path, WellKnownPath)
 	_, body, bodyErr := httpw.HTTPGet(url.String())
 
 	if bodyErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return nil, types.NewWrappedError(errorMessage, bodyErr)
 	}
 
 	endpoints := &ServerEndpoints{}
 	jsonErr := json.Unmarshal(body, endpoints)
 
 	if jsonErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: jsonErr}
+		return nil, types.NewWrappedError(errorMessage, jsonErr)
 	}
 
 	return endpoints, nil
@@ -51,20 +51,20 @@ func apiAuthorized(
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return nil, nil, types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// Join the paths
 	url, urlErr := url.Parse(base.Endpoints.API.V3.API)
 	if urlErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: urlErr}
+		return nil, nil, types.NewWrappedError(errorMessage, urlErr)
 	}
 	url.Path = path.Join(url.Path, endpoint)
 
 	// Make sure the tokens are valid, this will return an error if re-login is needed
 	oauthErr := EnsureTokens(server)
 	if oauthErr != nil {
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: oauthErr}
+		return nil, nil, types.NewWrappedError(errorMessage, oauthErr)
 	}
 
 	headerKey := "Authorization"
@@ -95,11 +95,11 @@ func apiAuthorizedRetry(
 			MarkTokenExpired(server)
 			retryHeader, retryBody, retryErr := apiAuthorized(server, method, endpoint, opts)
 			if retryErr != nil {
-				return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: retryErr}
+				return nil, nil, types.NewWrappedError(errorMessage, retryErr)
 			}
 			return retryHeader, retryBody, nil
 		}
-		return nil, nil, &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return nil, nil, types.NewWrappedError(errorMessage, bodyErr)
 	}
 	return header, body, nil
 }
@@ -108,19 +108,19 @@ func APIInfo(server Server) error {
 	errorMessage := "failed API /info"
 	_, body, bodyErr := apiAuthorizedRetry(server, http.MethodGet, "/info", nil)
 	if bodyErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: bodyErr}
+		return types.NewWrappedError(errorMessage, bodyErr)
 	}
 	structure := ServerProfileInfo{}
 	jsonErr := json.Unmarshal(body, &structure)
 
 	if jsonErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: jsonErr}
+		return types.NewWrappedError(errorMessage, jsonErr)
 	}
 
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// Store the profiles and make sure that the current profile is not overwritten
@@ -169,17 +169,17 @@ func APIConnectWireguard(
 		&httpw.HTTPOptionalParams{Headers: headers, Body: urlForm},
 	)
 	if connectErr != nil {
-		return "", "", time.Time{}, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     connectErr,
-		}
+		return "", "", time.Time{}, types.NewWrappedError(
+			errorMessage,
+			connectErr,
+		)
 	}
 
 	expires := header.Get("expires")
 
 	pTime, pTimeErr := http.ParseTime(expires)
 	if pTimeErr != nil {
-		return "", "", time.Time{}, &types.WrappedErrorMessage{Message: errorMessage, Err: pTimeErr}
+		return "", "", time.Time{}, types.NewWrappedError(errorMessage, pTimeErr)
 	}
 
 	contentType := header.Get("content-type")
@@ -210,13 +210,13 @@ func APIConnectOpenVPN(server Server, profile_id string, preferTCP bool) (string
 		&httpw.HTTPOptionalParams{Headers: headers, Body: urlForm},
 	)
 	if connectErr != nil {
-		return "", time.Time{}, &types.WrappedErrorMessage{Message: errorMessage, Err: connectErr}
+		return "", time.Time{}, types.NewWrappedError(errorMessage, connectErr)
 	}
 
 	expires := header.Get("expires")
 	pTime, pTimeErr := http.ParseTime(expires)
 	if pTimeErr != nil {
-		return "", time.Time{}, &types.WrappedErrorMessage{Message: errorMessage, Err: pTimeErr}
+		return "", time.Time{}, types.NewWrappedError(errorMessage, pTimeErr)
 	}
 	return string(connectBody), pTime, nil
 }
diff --git a/internal/server/common.go b/internal/server/common.go
index bf72bc6..bf6f4ca 100644
--- a/internal/server/common.go
+++ b/internal/server/common.go
@@ -97,10 +97,10 @@ func (servers *Servers) GetCurrentServer() (Server, error) {
 	errorMessage := "failed getting current server"
 	if servers.IsType == SecureInternetServerType {
 		if !servers.HasSecureLocation() {
-			return nil, &types.WrappedErrorMessage{
-				Message: errorMessage,
-				Err:     &ServerGetCurrentNotFoundError{},
-			}
+			return nil, types.NewWrappedError(
+				errorMessage,
+				&ServerGetCurrentNotFoundError{},
+			)
 		}
 		return &servers.SecureInternetHomeServer, nil
 	}
@@ -113,18 +113,18 @@ func (servers *Servers) GetCurrentServer() (Server, error) {
 	currentServerURL := serversStruct.CurrentURL
 	bases := serversStruct.Map
 	if bases == nil {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerGetCurrentNoMapError{},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerGetCurrentNoMapError{},
+		)
 	}
 	server, exists := bases[currentServerURL]
 
 	if !exists || server == nil {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerGetCurrentNotFoundError{},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerGetCurrentNotFoundError{},
+		)
 	}
 	return server, nil
 }
@@ -161,7 +161,7 @@ func (servers *Servers) addInstituteAndCustom(
 		discoServer.SupportContact,
 	)
 	if instituteInitErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: instituteInitErr}
+		return nil, types.NewWrappedError(errorMessage, instituteInitErr)
 	}
 	toAddServers.Map[url] = server
 	servers.IsType = serverType
@@ -192,7 +192,7 @@ func (servers *Servers) SetSecureLocation(
 	_, addLocationErr := servers.SecureInternetHomeServer.addLocation(chosenLocationServer)
 
 	if addLocationErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: addLocationErr}
+		return types.NewWrappedError(errorMessage, addLocationErr)
 	}
 
 	servers.SecureInternetHomeServer.CurrentLocation = chosenLocationServer.CountryCode
@@ -209,7 +209,7 @@ func (servers *Servers) AddSecureInternet(
 	initErr := servers.SecureInternetHomeServer.init(secureOrg, secureServer)
 
 	if initErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: initErr}
+		return nil, types.NewWrappedError(errorMessage, initErr)
 	}
 
 	servers.IsType = SecureInternetServerType
@@ -255,7 +255,7 @@ func ShouldRenewButton(server Server) bool {
 func GetISS(server Server) (string, error) {
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return "", &types.WrappedErrorMessage{Message: "failed getting server ISS", Err: baseErr}
+		return "", types.NewWrappedError("failed getting server ISS", baseErr)
 	}
 	// We have already ensured that the base URL ends with a /
 	return base.URL, nil
@@ -288,7 +288,7 @@ func MarkTokensForRenew(server Server) {
 func EnsureTokens(server Server) error {
 	ensureErr := server.GetOAuth().EnsureTokens()
 	if ensureErr != nil {
-		return &types.WrappedErrorMessage{Message: "failed ensuring server tokens", Err: ensureErr}
+		return types.NewWrappedError("failed ensuring server tokens", ensureErr)
 	}
 	return nil
 }
@@ -323,7 +323,7 @@ func getCurrentProfile(server Server) (*ServerProfile, error) {
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return nil, types.NewWrappedError(errorMessage, baseErr)
 	}
 	profileID := base.Profiles.Current
 	for _, profile := range base.Profiles.Info.ProfileList {
@@ -332,10 +332,10 @@ func getCurrentProfile(server Server) (*ServerProfile, error) {
 		}
 	}
 
-	return nil, &types.WrappedErrorMessage{
-		Message: errorMessage,
-		Err:     &ServerGetCurrentProfileNotFoundError{ProfileID: profileID},
-	}
+	return nil, types.NewWrappedError(
+		errorMessage,
+		&ServerGetCurrentProfileNotFoundError{ProfileID: profileID},
+	)
 }
 
 func wireguardGetConfig(server Server, preferTCP bool, supportsOpenVPN bool) (string, string, error) {
@@ -343,14 +343,14 @@ func wireguardGetConfig(server Server, preferTCP bool, supportsOpenVPN bool) (st
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return "", "", types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	profile_id := base.Profiles.Current
 	wireguardKey, wireguardErr := wireguard.GenerateKey()
 
 	if wireguardErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: wireguardErr}
+		return "", "", types.NewWrappedError(errorMessage, wireguardErr)
 	}
 
 	wireguardPublicKey := wireguardKey.PublicKey().String()
@@ -363,7 +363,7 @@ func wireguardGetConfig(server Server, preferTCP bool, supportsOpenVPN bool) (st
 	)
 
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	// Store start and end time
@@ -386,7 +386,7 @@ func openVPNGetConfig(server Server, preferTCP bool) (string, string, error) {
 	base, baseErr := server.GetBase()
 
 	if baseErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return "", "", types.NewWrappedError(errorMessage, baseErr)
 	}
 	profile_id := base.Profiles.Current
 	configOpenVPN, expires, configErr := APIConnectOpenVPN(server, profile_id, preferTCP)
@@ -396,7 +396,7 @@ func openVPNGetConfig(server Server, preferTCP bool) (string, string, error) {
 	base.EndTime = expires
 
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	return configOpenVPN, "openvpn", nil
@@ -409,12 +409,12 @@ func HasValidProfile(server Server) (bool, error) {
 	// This does not override the current profile
 	infoErr := APIInfo(server)
 	if infoErr != nil {
-		return false, &types.WrappedErrorMessage{Message: errorMessage, Err: infoErr}
+		return false, types.NewWrappedError(errorMessage, infoErr)
 	}
 
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return false, &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return false, types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// If there was a profile chosen and it doesn't exist anymore, reset it
@@ -442,7 +442,7 @@ func GetConfig(server Server, preferTCP bool) (string, string, error) {
 
 	profile, profileErr := getCurrentProfile(server)
 	if profileErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: profileErr}
+		return "", "", types.NewWrappedError(errorMessage, profileErr)
 	}
 
 	supportsOpenVPN := profile.supportsOpenVPN()
@@ -461,7 +461,7 @@ func GetConfig(server Server, preferTCP bool) (string, string, error) {
 	}
 
 	if configErr != nil {
-		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
+		return "", "", types.NewWrappedError(errorMessage, configErr)
 	}
 
 	return config, configType, nil
diff --git a/internal/server/custom.go b/internal/server/custom.go
index feda1f3..6ba6503 100644
--- a/internal/server/custom.go
+++ b/internal/server/custom.go
@@ -11,18 +11,18 @@ func (servers *Servers) SetCustomServer(server Server) error {
 	errorMessage := "failed setting custom server"
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	if base.Type != "custom_server" {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not a custom server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not a custom server"))
 	}
 
 	if _, ok := servers.CustomServers.Map[base.URL]; ok {
 		servers.CustomServers.CurrentURL = base.URL
 		servers.IsType = CustomServerType
 	} else {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not a custom server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not a custom server"))
 	}
 	return nil
 }
@@ -31,7 +31,7 @@ func (servers *Servers) GetCustomServer(url string) (*InstituteAccessServer, err
 	if server, ok := servers.CustomServers.Map[url]; ok {
 		return server, nil
 	}
-	return nil, &types.WrappedErrorMessage{Message: "failed to get institute access server", Err: fmt.Errorf("No custom server with URL: %s", url)}
+	return nil, types.NewWrappedError("failed to get institute access server", fmt.Errorf("No custom server with URL: %s", url))
 }
 
 func (servers *Servers) RemoveCustomServer(url string) {
diff --git a/internal/server/instituteaccess.go b/internal/server/instituteaccess.go
index bf0e2bc..0f097b0 100644
--- a/internal/server/instituteaccess.go
+++ b/internal/server/instituteaccess.go
@@ -26,18 +26,18 @@ func (servers *Servers) SetInstituteAccess(server Server) error {
 	errorMessage := "failed setting institute access server"
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	if base.Type != "institute_access" {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not an institute access server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not an institute access server"))
 	}
 
 	if _, ok := servers.InstituteServers.Map[base.URL]; ok {
 		servers.InstituteServers.CurrentURL = base.URL
 		servers.IsType = InstituteAccessServerType
 	} else {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("No such institute access server")}
+		return types.NewWrappedError(errorMessage, errors.New("No such institute access server"))
 	}
 	return nil
 }
@@ -46,7 +46,7 @@ func (servers *Servers) GetInstituteAccess(url string) (*InstituteAccessServer,
 	if server, ok := servers.InstituteServers.Map[url]; ok {
 		return server, nil
 	}
-	return nil, &types.WrappedErrorMessage{Message: "failed to get institute access server", Err: fmt.Errorf("No institute access server with URL: %s", url)}
+	return nil, types.NewWrappedError("failed to get institute access server", fmt.Errorf("No institute access server with URL: %s", url))
 }
 
 func (servers *Servers) RemoveInstituteAccess(url string) {
@@ -91,7 +91,7 @@ func (institute *InstituteAccessServer) init(
 	institute.Base.Type = serverType
 	endpoints, endpointsErr := APIGetEndpoints(url)
 	if endpointsErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: endpointsErr}
+		return types.NewWrappedError(errorMessage, endpointsErr)
 	}
 	institute.OAuth.Init(endpoints.API.V3.Authorization, endpoints.API.V3.Token)
 	institute.Base.Endpoints = *endpoints
diff --git a/internal/server/secureinternet.go b/internal/server/secureinternet.go
index 27d48a5..93e83cf 100644
--- a/internal/server/secureinternet.go
+++ b/internal/server/secureinternet.go
@@ -35,11 +35,11 @@ func (servers *Servers) SetSecureInternet(server Server) error {
 	errorMessage := "failed setting secure internet server"
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	if base.Type != "secure_internet" {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: errors.New("Not a secure internet server")}
+		return types.NewWrappedError(errorMessage, errors.New("Not a secure internet server"))
 	}
 
 	// The location should already be configured
@@ -71,19 +71,19 @@ func (secure *SecureInternetHomeServer) GetTemplateAuth() func(string) string {
 func (server *SecureInternetHomeServer) GetBase() (*ServerBase, error) {
 	errorMessage := "failed getting current secure internet home base"
 	if server.BaseMap == nil {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerSecureInternetMapNotFoundError{},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerSecureInternetMapNotFoundError{},
+		)
 	}
 
 	base, exists := server.BaseMap[server.CurrentLocation]
 
 	if !exists {
-		return nil, &types.WrappedErrorMessage{
-			Message: errorMessage,
-			Err:     &ServerSecureInternetBaseNotFoundError{Current: server.CurrentLocation},
-		}
+		return nil, types.NewWrappedError(
+			errorMessage,
+			&ServerSecureInternetBaseNotFoundError{Current: server.CurrentLocation},
+		)
 	}
 	return base, nil
 }
@@ -113,7 +113,7 @@ func (secure *SecureInternetHomeServer) addLocation(
 		base.Type = "secure_internet"
 		endpoints, endpointsErr := APIGetEndpoints(locationServer.BaseURL)
 		if endpointsErr != nil {
-			return nil, &types.WrappedErrorMessage{Message: errorMessage, Err: endpointsErr}
+			return nil, types.NewWrappedError(errorMessage, endpointsErr)
 		}
 		base.Endpoints = *endpoints
 	}
@@ -145,7 +145,7 @@ func (secure *SecureInternetHomeServer) init(
 	base, baseErr := secure.addLocation(homeLocation)
 
 	if baseErr != nil {
-		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
+		return types.NewWrappedError(errorMessage, baseErr)
 	}
 
 	// Make sure oauth contains our endpoints
diff --git a/internal/util/util.go b/internal/util/util.go
index a500e15..ef52ce2 100644
--- a/internal/util/util.go
+++ b/internal/util/util.go
@@ -15,10 +15,10 @@ import (
 func EnsureValidURL(s string) (string, error) {
 	parsedURL, parseErr := url.Parse(s)
 	if parseErr != nil {
-		return "", &types.WrappedErrorMessage{
-			Message: fmt.Sprintf("failed parsing url: %s", s),
-			Err:     parseErr,
-		}
+		return "", types.NewWrappedError(
+			fmt.Sprintf("failed parsing url: %s", s),
+			parseErr,
+		)
 	}
 
 	if parsedURL.Scheme == "" {
@@ -44,7 +44,7 @@ func MakeRandomByteSlice(size int) ([]byte, error) {
 	byteSlice := make([]byte, size)
 	_, err := rand.Read(byteSlice)
 	if err != nil {
-		return nil, &types.WrappedErrorMessage{Message: "failed reading random", Err: err}
+		return nil, types.NewWrappedError("failed reading random", err)
 	}
 	return byteSlice, nil
 }
@@ -57,10 +57,10 @@ func EnsureDirectory(directory string) error {
 	// Create with 700 permissions, read, write, execute only for the owner
 	mkdirErr := os.MkdirAll(directory, 0o700)
 	if mkdirErr != nil {
-		return &types.WrappedErrorMessage{
-			Message: fmt.Sprintf("failed to create directory %s", directory),
-			Err:     mkdirErr,
-		}
+		return types.NewWrappedError(
+			fmt.Sprintf("failed to create directory %s", directory),
+			mkdirErr,
+		)
 	}
 	return nil
 }
diff --git a/internal/verify/verify.go b/internal/verify/verify.go
index 43b6c74..2dd0472 100644
--- a/internal/verify/verify.go
+++ b/internal/verify/verify.go
@@ -39,7 +39,7 @@ func Verify(
 		forcePrehash,
 	)
 	if err != nil {
-		return valid, &types.WrappedErrorMessage{Message: "failed signature verify", Err: err}
+		return valid, types.NewWrappedError("failed signature verify", err)
 	}
 	return valid, nil
 }
diff --git a/internal/wireguard/wireguard.go b/internal/wireguard/wireguard.go
index 3d3ae8e..0a1ba5f 100644
--- a/internal/wireguard/wireguard.go
+++ b/internal/wireguard/wireguard.go
@@ -12,10 +12,10 @@ func GenerateKey() (wgtypes.Key, error) {
 	key, keyErr := wgtypes.GeneratePrivateKey()
 
 	if keyErr != nil {
-		return key, &types.WrappedErrorMessage{
-			Message: "failed generating WireGuard key",
-			Err:     keyErr,
-		}
+		return key, types.NewWrappedError(
+			"failed generating WireGuard key",
+			keyErr,
+		)
 	}
 	return key, nil
 }
diff --git a/types/error.go b/types/error.go
index c49fba2..dc4b90e 100644
--- a/types/error.go
+++ b/types/error.go
@@ -27,6 +27,16 @@ type WrappedErrorMessage struct {
 	Err     error
 }
 
+// NewWrappedError returns a WrappedErrorMessage and uses the error level from the parent
+func NewWrappedError(message string, err error) *WrappedErrorMessage {
+	return &WrappedErrorMessage{Level: GetErrorLevel(err), Message: message, Err: err}
+}
+
+// NewWrappedError returns a WrappedErrorMessage and uses the given error level from the parent
+func NewWrappedErrorLevel(level ErrorLevel, message string, err error) *WrappedErrorMessage {
+	return &WrappedErrorMessage{Level: level, Message: message, Err: err}
+}
+
 func (e *WrappedErrorMessage) Unwrap() error {
 	return e.Err
 }