Maint: upgrade golibs and env error wrapping

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/fatih/color v1.12.0
 	github.com/golang/mock v1.6.0
 	github.com/qdm12/dns v1.9.0
-	github.com/qdm12/golibs v0.0.0-20210716185557-66793f4ddd80
+	github.com/qdm12/golibs v0.0.0-20210721223530-ec1d3fe6dc99
 	github.com/qdm12/goshutdown v0.1.0
 	github.com/qdm12/gosplash v0.1.0
 	github.com/qdm12/ss-server v0.2.0

go.sum

@@ -66,8 +66,9 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/qdm12/dns v1.9.0 h1:p4g/BfbpQ+gJRpQdklDAnybkjds+OuenF0wEGoZ8/AI=
 github.com/qdm12/dns v1.9.0/go.mod h1:fqZoDf3VzddnKBMNI/OzZUp5H4dO0VBw1fp4qPkolOg=
 github.com/qdm12/golibs v0.0.0-20210603202746-e5494e9c2ebb/go.mod h1:15RBzkun0i8XB7ADIoLJWp9ITRgsz3LroEI2FiOXLRg=
-github.com/qdm12/golibs v0.0.0-20210716185557-66793f4ddd80 h1:rvH2MSs8RXEfuXivzoYCim6tRNPzdqjBzqJq8w4Tc0k=
 github.com/qdm12/golibs v0.0.0-20210716185557-66793f4ddd80/go.mod h1:15RBzkun0i8XB7ADIoLJWp9ITRgsz3LroEI2FiOXLRg=
+github.com/qdm12/golibs v0.0.0-20210721223530-ec1d3fe6dc99 h1:2OKHAR0SK8BtTtWCRNoSn58eh+iVDA3Cwq4i2CnD3i4=
+github.com/qdm12/golibs v0.0.0-20210721223530-ec1d3fe6dc99/go.mod h1:6aRbg4Z/bTbm9JfxsGXfWKHi7zsOvPfUTK1S5HuAFKg=
 github.com/qdm12/goshutdown v0.1.0 h1:lmwnygdXtnr2pa6VqfR/bm8077/BnBef1+7CP96B7Sw=
 github.com/qdm12/goshutdown v0.1.0/go.mod h1:/LP3MWLqI+wGH/ijfaUG+RHzBbKXIiVKnrg5vXOCf6Q=
 github.com/qdm12/gosplash v0.1.0 h1:Sfl+zIjFZFP7b0iqf2l5UkmEY97XBnaKkH3FNY6Gf7g=
@@ -105,8 +106,9 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a h1:kr2P4QFmQr29mSLA43kwrOcgcReGTfbE9N577tCTuBc=
 golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 h1:/UOmuWzQfxxo9UtlXMwuQU8CMgg1eZXqTRwkSQJWKOI=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
@@ -136,6 +138,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

internal/configuration/cyberghost.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 	"github.com/qdm12/golibs/params"
 )
@@ -53,17 +55,17 @@ func (settings *Provider) readCyberghost(r reader) (err error) {
 	settings.ServerSelection.Group, err = r.env.Inside("CYBERGHOST_GROUP",
 		constants.CyberghostGroupChoices(), params.Default("Premium UDP Europe"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CYBERGHOST_GROUP: %w", err)
 	}
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.CyberghostRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.CyberghostHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/dns.go

@@ -68,7 +68,7 @@ var (
 func (settings *DNS) read(r reader) (err error) {
 	settings.Enabled, err = r.env.OnOff("DOT", params.Default("on"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT: %w", err)
 	}
 
 	// Plain DNS settings
@@ -77,7 +77,7 @@ func (settings *DNS) read(r reader) (err error) {
 	}
 	settings.KeepNameserver, err = r.env.OnOff("DNS_KEEP_NAMESERVER", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DNS_KEEP_NAMESERVER: %w", err)
 	}
 
 	// DNS over TLS external settings
@@ -87,7 +87,7 @@ func (settings *DNS) read(r reader) (err error) {
 
 	settings.UpdatePeriod, err = r.env.Duration("DNS_UPDATE_PERIOD", params.Default("24h"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DNS_UPDATE_PERIOD: %w", err)
 	}
 
 	// Unbound settings
@@ -105,7 +105,7 @@ var (
 func (settings *DNS) readDNSPlaintext(env params.Env) error {
 	s, err := env.Get("DNS_PLAINTEXT_ADDRESS", params.Default("1.1.1.1"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DNS_PLAINTEXT_ADDRESS: %w", err)
 	}
 
 	settings.PlaintextAddress = net.ParseIP(s)

internal/configuration/dnsblacklist.go

@@ -11,18 +11,18 @@ import (
 func (settings *DNS) readBlacklistBuilding(r reader) (err error) {
 	settings.BlacklistBuild.BlockMalicious, err = r.env.OnOff("BLOCK_MALICIOUS", params.Default("on"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable BLOCK_MALICIOUS: %w", err)
 	}
 
 	settings.BlacklistBuild.BlockSurveillance, err = r.env.OnOff("BLOCK_SURVEILLANCE", params.Default("on"),
 		params.RetroKeys([]string{"BLOCK_NSA"}, r.onRetroActive))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable BLOCK_SURVEILLANCE (or BLOCK_NSA): %w", err)
 	}
 
 	settings.BlacklistBuild.BlockAds, err = r.env.OnOff("BLOCK_ADS", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable BLOCK_ADS: %w", err)
 	}
 
 	if err := settings.readPrivateAddresses(r.env); err != nil {
@@ -39,7 +39,7 @@ var (
 func (settings *DNS) readPrivateAddresses(env params.Env) (err error) {
 	privateAddresses, err := env.CSV("DOT_PRIVATE_ADDRESS")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_PRIVATE_ADDRESS: %w", err)
 	} else if len(privateAddresses) == 0 {
 		return nil
 	}
@@ -72,7 +72,7 @@ func (settings *DNS) readPrivateAddresses(env params.Env) (err error) {
 func (settings *DNS) readBlacklistUnblockedHostnames(r reader) (err error) {
 	hostnames, err := r.env.CSV("UNBLOCK")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable UNBLOCK: %w", err)
 	} else if len(hostnames) == 0 {
 		return nil
 	}

internal/configuration/fastestvpn.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -31,12 +33,12 @@ func (settings *Provider) readFastestvpn(r reader) (err error) {
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.FastestvpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.FastestvpnCountriesChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	return nil

internal/configuration/firewall.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"net"
 	"strings"
 
@@ -53,12 +54,12 @@ func (settings *Firewall) lines() (lines []string) {
 func (settings *Firewall) read(r reader) (err error) {
 	settings.Enabled, err = r.env.OnOff("FIREWALL", params.Default("on"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable FIREWALL: %w", err)
 	}
 
 	settings.Debug, err = r.env.OnOff("FIREWALL_DEBUG", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable FIREWALL_DEBUG: %w", err)
 	}
 
 	if err := settings.readVPNInputPorts(r.env); err != nil {
@@ -74,16 +75,25 @@ func (settings *Firewall) read(r reader) (err error) {
 
 func (settings *Firewall) readVPNInputPorts(env params.Env) (err error) {
 	settings.VPNInputPorts, err = readCSVPorts(env, "FIREWALL_VPN_INPUT_PORTS")
-	return err
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_VPN_INPUT_PORTS: %w", err)
+	}
+	return nil
 }
 
 func (settings *Firewall) readInputPorts(env params.Env) (err error) {
 	settings.InputPorts, err = readCSVPorts(env, "FIREWALL_INPUT_PORTS")
-	return err
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_INPUT_PORTS: %w", err)
+	}
+	return nil
 }
 
 func (settings *Firewall) readOutboundSubnets(r reader) (err error) {
 	retroOption := params.RetroKeys([]string{"EXTRA_SUBNETS"}, r.onRetroActive)
 	settings.OutboundSubnets, err = readCSVIPNets(r.env, "FIREWALL_OUTBOUND_SUBNETS", retroOption)
-	return err
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_OUTBOUND_SUBNETS: %w", err)
+	}
+	return nil
 }

internal/configuration/health.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/qdm12/golibs/logging"
@@ -42,20 +43,20 @@ func (settings *Health) read(r reader) (err error) {
 	settings.ServerAddress, warning, err = r.env.ListeningAddress(
 		"HEALTH_SERVER_ADDRESS", params.Default("127.0.0.1:9999"))
 	if warning != "" {
-		r.logger.Warn("health server address: " + warning)
+		r.logger.Warn("environment variable HEALTH_SERVER_ADDRESS: " + warning)
 	}
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HEALTH_SERVER_ADDRESS: %w", err)
 	}
 
 	settings.OpenVPN.Initial, err = r.env.Duration("HEALTH_OPENVPN_DURATION_INITIAL", params.Default("6s"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HEALTH_OPENVPN_DURATION_INITIAL: %w", err)
 	}
 
 	settings.OpenVPN.Addition, err = r.env.Duration("HEALTH_OPENVPN_DURATION_ADDITION", params.Default("5s"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HEALTH_OPENVPN_DURATION_ADDITION: %w", err)
 	}
 
 	return nil

internal/configuration/health_test.go

@@ -105,7 +105,7 @@ func Test_Health_read(t *testing.T) {
 			expected: Health{
 				ServerAddress: "127.0.0.1:9999",
 			},
-			err: errDummy,
+			err: errors.New("environment variable HEALTH_SERVER_ADDRESS: dummy"),
 		},
 		"initial error": {
 			openvpnInitialDuration:  time.Second,
@@ -116,7 +116,7 @@ func Test_Health_read(t *testing.T) {
 					Initial: time.Second,
 				},
 			},
-			err: errDummy,
+			err: errors.New("environment variable HEALTH_OPENVPN_DURATION_INITIAL: dummy"),
 		},
 		"addition error": {
 			openvpnInitialDuration:  time.Second,
@@ -128,7 +128,7 @@ func Test_Health_read(t *testing.T) {
 					Addition: time.Minute,
 				},
 			},
-			err: errDummy,
+			err: errors.New("environment variable HEALTH_OPENVPN_DURATION_ADDITION: dummy"),
 		},
 	}
 
@@ -146,7 +146,7 @@ func Test_Health_read(t *testing.T) {
 				Return(testCase.serverAddress, testCase.serverAddressWarning,
 					testCase.serverAddressErr)
 			if testCase.serverAddressWarning != "" {
-				logger.EXPECT().Warn("health server address: " + testCase.serverAddressWarning)
+				logger.EXPECT().Warn("environment variable HEALTH_SERVER_ADDRESS: " + testCase.serverAddressWarning)
 			}
 
 			if testCase.serverAddressErr == nil {

internal/configuration/hidemyass.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -39,22 +41,22 @@ func (settings *Provider) readHideMyAss(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.HideMyAssCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.HideMyAssCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.HideMyAssCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.HideMyAssHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/httpproxy.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -49,24 +50,24 @@ func (settings *HTTPProxy) read(r reader) (err error) {
 	settings.Enabled, err = r.env.OnOff("HTTPPROXY", params.Default("off"),
 		params.RetroKeys([]string{"TINYPROXY", "PROXY"}, r.onRetroActive))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTPPROXY (or TINYPROXY, PROXY): %w", err)
 	}
 
 	settings.User, err = r.getFromEnvOrSecretFile("HTTPPROXY_USER", false, // compulsory
 		[]string{"TINYPROXY_USER", "PROXY_USER"})
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTPPROXY_USER (or TINYPROXY_USER, PROXY_USER): %w", err)
 	}
 
 	settings.Password, err = r.getFromEnvOrSecretFile("HTTPPROXY_PASSWORD", false,
 		[]string{"TINYPROXY_PASSWORD", "PROXY_PASSWORD"})
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTPPROXY_PASSWORD (or TINYPROXY_PASSWORD, PROXY_PASSWORD): %w", err)
 	}
 
 	settings.Stealth, err = r.env.OnOff("HTTPPROXY_STEALTH", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTPPROXY_STEALTH: %w", err)
 	}
 
 	if err := settings.readLog(r); err != nil {
@@ -80,7 +81,7 @@ func (settings *HTTPProxy) read(r reader) (err error) {
 		r.logger.Warn(warning)
 	}
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTPPROXY_PORT (or TINYPROXY_PORT, PROXY_PORT): %w", err)
 	}
 
 	return nil
@@ -90,7 +91,7 @@ func (settings *HTTPProxy) readLog(r reader) error {
 	s, err := r.env.Get("HTTPPROXY_LOG",
 		params.RetroKeys([]string{"PROXY_LOG_LEVEL", "TINYPROXY_LOG"}, r.onRetroActive))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTPPROXY_LOG (or TINYPROXY_LOG, PROXY_LOG_LEVEL): %w", err)
 	}
 
 	switch strings.ToLower(s) {

internal/configuration/ipvanish.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -35,17 +37,17 @@ func (settings *Provider) readIpvanish(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.IpvanishCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.IpvanishCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.IpvanishHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/ipvanish_test.go

@@ -78,7 +78,7 @@ func Test_Provider_readIpvanish(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ipvanish,
 			},
-			err: errDummy,
+			err: errors.New("environment variable PROTOCOL: dummy test error"),
 		},
 		"target IP error": {
 			protocol: singleStringCall{call: true},
@@ -86,7 +86,7 @@ func Test_Provider_readIpvanish(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ipvanish,
 			},
-			err: errDummy,
+			err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"),
 		},
 		"countries error": {
 			protocol:  singleStringCall{call: true},
@@ -95,7 +95,7 @@ func Test_Provider_readIpvanish(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ipvanish,
 			},
-			err: errDummy,
+			err: errors.New("environment variable COUNTRY: dummy test error"),
 		},
 		"cities error": {
 			protocol:  singleStringCall{call: true},
@@ -105,7 +105,7 @@ func Test_Provider_readIpvanish(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ipvanish,
 			},
-			err: errDummy,
+			err: errors.New("environment variable CITY: dummy test error"),
 		},
 		"hostnames error": {
 			protocol:  singleStringCall{call: true},
@@ -116,7 +116,7 @@ func Test_Provider_readIpvanish(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ipvanish,
 			},
-			err: errDummy,
+			err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"),
 		},
 		"default settings": {
 			protocol:  singleStringCall{call: true},

internal/configuration/ivpn.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -35,17 +37,17 @@ func (settings *Provider) readIvpn(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.IvpnCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.IvpnCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.IvpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/ivpn_test.go

@@ -78,7 +78,7 @@ func Test_Provider_readIvpn(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ivpn,
 			},
-			err: errDummy,
+			err: errors.New("environment variable PROTOCOL: dummy test error"),
 		},
 		"target IP error": {
 			protocol: singleStringCall{call: true},
@@ -86,7 +86,7 @@ func Test_Provider_readIvpn(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ivpn,
 			},
-			err: errDummy,
+			err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"),
 		},
 		"countries error": {
 			protocol:  singleStringCall{call: true},
@@ -95,7 +95,7 @@ func Test_Provider_readIvpn(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ivpn,
 			},
-			err: errDummy,
+			err: errors.New("environment variable COUNTRY: dummy test error"),
 		},
 		"cities error": {
 			protocol:  singleStringCall{call: true},
@@ -105,7 +105,7 @@ func Test_Provider_readIvpn(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ivpn,
 			},
-			err: errDummy,
+			err: errors.New("environment variable CITY: dummy test error"),
 		},
 		"hostnames error": {
 			protocol:  singleStringCall{call: true},
@@ -116,7 +116,7 @@ func Test_Provider_readIvpn(t *testing.T) {
 			settings: Provider{
 				Name: constants.Ivpn,
 			},
-			err: errDummy,
+			err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"),
 		},
 		"default settings": {
 			protocol:  singleStringCall{call: true},

internal/configuration/mullvad.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/qdm12/gluetun/internal/constants"
@@ -50,22 +51,22 @@ func (settings *Provider) readMullvad(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.MullvadCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.MullvadCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.MullvadHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.ISPs, err = r.env.CSVInside("ISP", constants.MullvadISPChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable ISP: %w", err)
 	}
 
 	settings.ServerSelection.CustomPort, err = readCustomPort(r.env, settings.ServerSelection.TCP,
@@ -76,12 +77,12 @@ func (settings *Provider) readMullvad(r reader) (err error) {
 
 	settings.ServerSelection.Owned, err = r.env.YesNo("OWNED", params.Default("no"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OWNED: %w", err)
 	}
 
 	settings.ExtraConfigOptions.OpenVPNIPv6, err = r.env.OnOff("OPENVPN_IPV6", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_IPV6: %w", err)
 	}
 
 	return nil

internal/configuration/nordvpn.go

@@ -47,17 +47,17 @@ func (settings *Provider) readNordvpn(r reader) (err error) {
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.NordvpnRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.NordvpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.Names, err = r.env.CSVInside("SERVER_NAME", constants.NordvpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_NAME: %w", err)
 	}
 
 	settings.ServerSelection.Numbers, err = readNordVPNServerNumbers(r.env)

internal/configuration/openvpn.go

@@ -78,7 +78,7 @@ func (settings *OpenVPN) read(r reader) (err error) {
 		"purevpn", "surfshark", "torguard", constants.VPNUnlimited, "vyprvpn", "windscribe"},
 		params.Default("private internet access"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable VPNSP: %w", err)
 	}
 	if vpnsp == "pia" { // retro compatibility
 		vpnsp = "private internet access"
@@ -88,7 +88,7 @@ func (settings *OpenVPN) read(r reader) (err error) {
 
 	settings.Config, err = r.env.Get("OPENVPN_CUSTOM_CONFIG", params.CaseSensitiveValue())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_CUSTOM_CONFIG: %w", err)
 	}
 	customConfig := settings.Config != ""
 
@@ -100,7 +100,7 @@ func (settings *OpenVPN) read(r reader) (err error) {
 
 	settings.User, err = r.getFromEnvOrSecretFile("OPENVPN_USER", credentialsRequired, []string{"USER"})
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_USER: %w", err)
 	}
 	// Remove spaces in user ID to simplify user's life, thanks @JeordyR
 	settings.User = strings.ReplaceAll(settings.User, " ", "")
@@ -117,18 +117,18 @@ func (settings *OpenVPN) read(r reader) (err error) {
 	settings.Version, err = r.env.Inside("OPENVPN_VERSION",
 		[]string{constants.Openvpn24, constants.Openvpn25}, params.Default(constants.Openvpn25))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_VERSION: %w", err)
 	}
 
 	settings.Verbosity, err = r.env.IntRange("OPENVPN_VERBOSITY", 0, 6, params.Default("1")) //nolint:gomnd
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_VERBOSITY: %w", err)
 	}
 
 	settings.Flags = []string{}
 	flagsStr, err := r.env.Get("OPENVPN_FLAGS")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_FLAGS: %w", err)
 	}
 	if flagsStr != "" {
 		settings.Flags = strings.Fields(flagsStr)
@@ -136,23 +136,23 @@ func (settings *OpenVPN) read(r reader) (err error) {
 
 	settings.Root, err = r.env.YesNo("OPENVPN_ROOT", params.Default("yes"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_ROOT: %w", err)
 	}
 
 	settings.Cipher, err = r.env.Get("OPENVPN_CIPHER")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_CIPHER: %w", err)
 	}
 
 	settings.Auth, err = r.env.Get("OPENVPN_AUTH")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_AUTH: %w", err)
 	}
 
 	const maxMSSFix = 10000
 	mssFix, err := r.env.IntRange("OPENVPN_MSSFIX", 0, maxMSSFix, params.Default("0"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable OPENVPN_MSSFIX: %w", err)
 	}
 	settings.MSSFix = uint16(mssFix)
 	return settings.readProvider(r)

internal/configuration/privado.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -39,22 +41,22 @@ func (settings *Provider) readPrivado(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PrivadoCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PrivadoRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PrivadoCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PrivadoHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/privateinternetaccess.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/qdm12/gluetun/internal/constants"
@@ -55,41 +56,41 @@ func (settings *Provider) readPrivateInternetAccess(r reader) (err error) {
 		params.Default(constants.PIACertificateStrong),
 	)
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PIA_ENCRYPTION: %w", err)
 	}
 	settings.ServerSelection.EncryptionPreset = encryptionPreset
 	settings.ExtraConfigOptions.EncryptionPreset = encryptionPreset
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PIAGeoChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PIAHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_NAME", constants.PIANameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_NAME: %w", err)
 	}
 
 	settings.ServerSelection.CustomPort, err = readPortOrZero(r.env, "PORT")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PORT: %w", err)
 	}
 
 	settings.PortForwarding.Enabled, err = r.env.OnOff("PORT_FORWARDING", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PORT_FORWARDING: %w", err)
 	}
 
 	if settings.PortForwarding.Enabled {
 		settings.PortForwarding.Filepath, err = r.env.Path("PORT_FORWARDING_STATUS_FILE",
 			params.Default("/tmp/gluetun/forwarded_port"), params.CaseSensitiveValue())
 		if err != nil {
-			return err
+			return fmt.Errorf("environment variable PORT_FORWARDING_STATUS_FILE: %w", err)
 		}
 	}
 

internal/configuration/privatevpn.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -35,17 +37,17 @@ func (settings *Provider) readPrivatevpn(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PrivatevpnCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PrivatevpnCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PrivatevpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/protonvpn.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 	"github.com/qdm12/golibs/params"
 )
@@ -48,37 +50,37 @@ func (settings *Provider) readProtonvpn(r reader) (err error) {
 
 	settings.ServerSelection.CustomPort, err = readPortOrZero(r.env, "PORT")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PORT: %w", err)
 	}
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.ProtonvpnCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.ProtonvpnRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.ProtonvpnCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Names, err = r.env.CSVInside("SERVER_NAME", constants.ProtonvpnNameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_NAME: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.ProtonvpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.FreeOnly, err = r.env.YesNo("FREE_ONLY", params.Default("no"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable FREE_ONLY: %w", err)
 	}
 
 	return nil

internal/configuration/provider.go

@@ -83,7 +83,7 @@ func commaJoin(slice []string) string {
 func readProtocol(env params.Env) (tcp bool, err error) {
 	protocol, err := env.Inside("PROTOCOL", []string{constants.TCP, constants.UDP}, params.Default(constants.UDP))
 	if err != nil {
-		return false, err
+		return false, fmt.Errorf("environment variable PROTOCOL: %w", err)
 	}
 	return protocol == constants.TCP, nil
 }
@@ -96,14 +96,18 @@ func protoToString(tcp bool) string {
 }
 
 func readTargetIP(env params.Env) (targetIP net.IP, err error) {
-	return readIP(env, "OPENVPN_TARGET_IP")
+	targetIP, err = readIP(env, "OPENVPN_TARGET_IP")
+	if err != nil {
+		return nil, fmt.Errorf("environment variable OPENVPN_TARGET_IP: %w", err)
+	}
+	return targetIP, nil
 }
 
 func readCustomPort(env params.Env, tcp bool,
 	allowedTCP, allowedUDP []uint16) (port uint16, err error) {
 	port, err = readPortOrZero(env, "PORT")
 	if err != nil {
-		return 0, err
+		return 0, fmt.Errorf("environment variable PORT: %w", err)
 	} else if port == 0 {
 		return 0, nil
 	}
@@ -114,12 +118,12 @@ func readCustomPort(env params.Env, tcp bool,
 				return port, nil
 			}
 		}
-		return 0, fmt.Errorf("%w: port %d for TCP protocol", ErrInvalidPort, port)
+		return 0, fmt.Errorf("environment variable PORT: %w: port %d for TCP protocol", ErrInvalidPort, port)
 	}
 	for i := range allowedUDP {
 		if allowedUDP[i] == port {
 			return port, nil
 		}
 	}
-	return 0, fmt.Errorf("%w: port %d for UDP protocol", ErrInvalidPort, port)
+	return 0, fmt.Errorf("environment variable PORT: %w: port %d for UDP protocol", ErrInvalidPort, port)
 }

internal/configuration/provider_test.go

@@ -348,7 +348,7 @@ func Test_readProtocol(t *testing.T) {
 	}{
 		"error": {
 			mockErr: errDummy,
-			err:     errDummy,
+			err:     errors.New("environment variable PROTOCOL: dummy"),
 		},
 		"success": {
 			mockStr: "tcp",

internal/configuration/publicip.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strings"
 	"time"
 
@@ -32,14 +33,14 @@ func (settings *PublicIP) lines() (lines []string) {
 func (settings *PublicIP) read(r reader) (err error) {
 	settings.Period, err = r.env.Duration("PUBLICIP_PERIOD", params.Default("12h"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PUBLICIP_PERIOD: %w", err)
 	}
 
 	settings.IPFilepath, err = r.env.Path("PUBLICIP_FILE", params.CaseSensitiveValue(),
 		params.Default("/tmp/gluetun/ip"),
 		params.RetroKeys([]string{"IP_STATUS_FILE"}, r.onRetroActive))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PUBLICIP_FILE (or IP_STATUS_FILE): %w", err)
 	}
 
 	return nil

internal/configuration/purevpn.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -39,22 +41,22 @@ func (settings *Provider) readPurevpn(r reader) (err error) {
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PurevpnRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PurevpnCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PurevpnCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PurevpnHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/reader.go

@@ -53,11 +53,9 @@ func readCSVPorts(env params.Env, key string) (ports []uint16, err error) {
 	for i, portStr := range portsStr {
 		portInt, err := strconv.Atoi(portStr)
 		if err != nil {
-			return nil, fmt.Errorf("%w: %q from environment variable %s: %s",
-				ErrInvalidPort, portStr, key, err)
+			return nil, fmt.Errorf("%w: %s: %s", ErrInvalidPort, portStr, err)
 		} else if portInt <= 0 || portInt > 65535 {
-			return nil, fmt.Errorf("%w: %d from environment variable %s: must be between 1 and 65535",
-				ErrInvalidPort, portInt, key)
+			return nil, fmt.Errorf("%w: %d: must be between 1 and 65535", ErrInvalidPort, portInt)
 		}
 		ports[i] = uint16(portInt)
 	}
@@ -83,11 +81,10 @@ func readCSVIPNets(env params.Env, key string, options ...params.OptionSetter) (
 	for i, ipNetStr := range ipNetsStr {
 		_, ipNet, err := net.ParseCIDR(ipNetStr)
 		if err != nil {
-			return nil, fmt.Errorf("%w: %q from environment variable %s: %s",
-				ErrInvalidIPNet, ipNetStr, key, err)
+			return nil, fmt.Errorf("%w: %s: %s",
+				ErrInvalidIPNet, ipNetStr, err)
 		} else if ipNet == nil {
-			return nil, fmt.Errorf("%w: %q from environment variable %s: subnet is nil",
-				ErrInvalidIPNet, ipNetStr, key)
+			return nil, fmt.Errorf("%w: %s: subnet is nil", ErrInvalidIPNet, ipNetStr)
 		}
 		ipNets[i] = *ipNet
 	}

internal/configuration/secrets.go

@@ -37,13 +37,15 @@ func (r *reader) getFromEnvOrSecretFile(envKey string, compulsory bool, retroKey
 		return value, nil
 	}
 
+	secretFilepathEnvKey := envKey + "_SECRETFILE"
 	defaultSecretFile := "/run/secrets/" + strings.ToLower(envKey)
-	filepath, err := r.env.Get(envKey+"_SECRETFILE",
+	filepath, err := r.env.Get(secretFilepathEnvKey,
 		params.CaseSensitiveValue(),
 		params.Default(defaultSecretFile),
 	)
 	if err != nil {
-		return "", fmt.Errorf("%w: %s", ErrGetSecretFilepath, err)
+		return "", fmt.Errorf("%w: environment variable %s: %s",
+			ErrGetSecretFilepath, secretFilepathEnvKey, err)
 	}
 
 	file, fileErr := r.os.OpenFile(filepath, os.O_RDONLY, 0)
@@ -74,12 +76,13 @@ func (r *reader) getFromEnvOrSecretFile(envKey string, compulsory bool, retroKey
 func (r *reader) getFromFileOrSecretFile(secretName, filepath string) (
 	b []byte, err error) {
 	defaultSecretFile := "/run/secrets/" + strings.ToLower(secretName)
-	secretFilepath, err := r.env.Get(strings.ToUpper(secretName)+"_SECRETFILE",
+	key := strings.ToUpper(secretName) + "_SECRETFILE"
+	secretFilepath, err := r.env.Get(key,
 		params.CaseSensitiveValue(),
 		params.Default(defaultSecretFile),
 	)
 	if err != nil {
-		return b, fmt.Errorf("%w: %s", ErrGetSecretFilepath, err)
+		return b, fmt.Errorf("environment variable %s: %w: %s", key, ErrGetSecretFilepath, err)
 	}
 
 	b, err = readFromFile(r.os.OpenFile, secretFilepath)

internal/configuration/server.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -32,7 +33,7 @@ func (settings *ControlServer) lines() (lines []string) {
 func (settings *ControlServer) read(r reader) (err error) {
 	settings.Log, err = r.env.OnOff("HTTP_CONTROL_SERVER_LOG", params.Default("on"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTP_CONTROL_SERVER_LOG: %w", err)
 	}
 
 	var warning string
@@ -42,7 +43,7 @@ func (settings *ControlServer) read(r reader) (err error) {
 		r.logger.Warn(warning)
 	}
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable HTTP_CONTROL_SERVER_PORT: %w", err)
 	}
 
 	return nil

internal/configuration/settings.go

@@ -67,7 +67,7 @@ func (settings *Settings) Read(env params.Env, os os.OS, logger logging.Logger)
 
 	settings.VersionInformation, err = r.env.OnOff("VERSION_INFORMATION", params.Default("on"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable VERSION_INFORMATION: %w", err)
 	}
 
 	if err := settings.OpenVPN.read(r); err != nil {

internal/configuration/shadowsocks.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -40,8 +41,10 @@ func (settings *ShadowSocks) lines() (lines []string) {
 
 func (settings *ShadowSocks) read(r reader) (err error) {
 	settings.Enabled, err = r.env.OnOff("SHADOWSOCKS", params.Default("off"))
-	if err != nil || !settings.Enabled {
-		return err
+	if !settings.Enabled {
+		return nil
+	} else if err != nil {
+		return fmt.Errorf("environment variable SHADOWSOCKS: %w", err)
 	}
 
 	settings.Password, err = r.getFromEnvOrSecretFile("SHADOWSOCKS_PASSWORD", settings.Enabled, nil)
@@ -51,12 +54,12 @@ func (settings *ShadowSocks) read(r reader) (err error) {
 
 	settings.Log, err = r.env.OnOff("SHADOWSOCKS_LOG", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SHADOWSOCKS_LOG: %w", err)
 	}
 
 	settings.Method, err = r.env.Get("SHADOWSOCKS_METHOD", params.Default("chacha20-ietf-poly1305"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SHADOWSOCKS_METHOD: %w", err)
 	}
 
 	var warning string
@@ -65,7 +68,7 @@ func (settings *ShadowSocks) read(r reader) (err error) {
 		r.logger.Warn(warning)
 	}
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SHADOWSOCKS_PORT: %w", err)
 	}
 
 	return nil

internal/configuration/surfshark.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -31,12 +33,12 @@ func (settings *Provider) readSurfshark(r reader) (err error) {
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.SurfsharkRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.SurfsharkHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/system.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -36,18 +37,18 @@ func (settings *System) read(r reader) (err error) {
 	settings.PUID, err = r.env.IntRange("PUID", 0, maxID, params.Default("1000"),
 		params.RetroKeys([]string{"UID"}, r.onRetroActive))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PUID (or UID): %w", err)
 	}
 
 	settings.PGID, err = r.env.IntRange("PGID", 0, maxID, params.Default("1000"),
 		params.RetroKeys([]string{"GID"}, r.onRetroActive))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable PGID (or GID): %w", err)
 	}
 
 	settings.Timezone, err = r.env.Get("TZ")
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable TZ: %w", err)
 	}
 
 	return nil

internal/configuration/torguard.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -35,17 +37,17 @@ func (settings *Provider) readTorguard(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.TorguardCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.TorguardCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.TorguardHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	return nil

internal/configuration/unbound.go

@@ -19,31 +19,31 @@ func (settings *DNS) readUnbound(r reader) (err error) {
 
 	settings.Unbound.Caching, err = r.env.OnOff("DOT_CACHING", params.Default("on"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_CACHING: %w", err)
 	}
 
 	settings.Unbound.IPv4 = true
 
 	settings.Unbound.IPv6, err = r.env.OnOff("DOT_IPV6", params.Default("off"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_IPV6: %w", err)
 	}
 
 	verbosityLevel, err := r.env.IntRange("DOT_VERBOSITY", 0, 5, params.Default("1")) //nolint:gomnd
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_VERBOSITY: %w", err)
 	}
 	settings.Unbound.VerbosityLevel = uint8(verbosityLevel)
 
 	verbosityDetailsLevel, err := r.env.IntRange("DOT_VERBOSITY_DETAILS", 0, 4, params.Default("0")) //nolint:gomnd
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_VERBOSITY_DETAILS: %w", err)
 	}
 	settings.Unbound.VerbosityDetailsLevel = uint8(verbosityDetailsLevel)
 
 	validationLogLevel, err := r.env.IntRange("DOT_VALIDATION_LOGLEVEL", 0, 2, params.Default("0")) //nolint:gomnd
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_VALIDATION_LOGLEVEL: %w", err)
 	}
 	settings.Unbound.ValidationLogLevel = uint8(validationLogLevel)
 
@@ -62,7 +62,7 @@ var (
 func (settings *DNS) readUnboundProviders(env params.Env) (err error) {
 	s, err := env.Get("DOT_PROVIDERS", params.Default("cloudflare"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable DOT_PROVIDERS: %w", err)
 	}
 	for _, field := range strings.Split(s, ",") {
 		dnsProvider, err := provider.Parse(field)

internal/configuration/updater.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strings"
 	"time"
 
@@ -74,7 +75,7 @@ func (settings *Updater) read(r reader) (err error) {
 
 	settings.Period, err = r.env.Duration("UPDATER_PERIOD", params.Default("0"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable UPDATER_PERIOD: %w", err)
 	}
 
 	return nil

internal/configuration/vpnunlimited.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 	"github.com/qdm12/golibs/params"
 )
@@ -58,27 +60,27 @@ func (settings *Provider) readVPNUnlimited(r reader) (err error) {
 
 	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.VPNUnlimitedCountryChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.VPNUnlimitedCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.VPNUnlimitedHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.FreeOnly, err = r.env.YesNo("FREE_ONLY", params.Default("no"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable FREE_ONLY: %w", err)
 	}
 
 	settings.ServerSelection.StreamOnly, err = r.env.YesNo("STREAM_ONLY", params.Default("no"))
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable STREAM_ONLY: %w", err)
 	}
 
 	return nil

internal/configuration/vyprvpn.go

@@ -1,6 +1,8 @@
 package configuration
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/constants"
 )
 
@@ -27,7 +29,7 @@ func (settings *Provider) readVyprvpn(r reader) (err error) {
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.VyprvpnRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	return nil

internal/configuration/windscribe.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/qdm12/gluetun/internal/constants"
@@ -41,17 +42,17 @@ func (settings *Provider) readWindscribe(r reader) (err error) {
 
 	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.WindscribeRegionChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable REGION: %w", err)
 	}
 
 	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.WindscribeCityChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable CITY: %w", err)
 	}
 
 	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.WindscribeHostnameChoices())
 	if err != nil {
-		return err
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
 	}
 
 	settings.ServerSelection.CustomPort, err = readCustomPort(r.env, settings.ServerSelection.TCP,