Maint: pass only single strings to logger methods

- Do not assume formatting from logger's interface
- Allow to change golibs in the future to accept only strings for logger methods

internal/httpproxy/accept.go

@@ -16,7 +16,7 @@ func (h *handler) isAccepted(responseWriter http.ResponseWriter, request *http.R
 	if !request.ProtoAtLeast(minimalMajorVersion, minimalMinorVersion) ||
 		request.ProtoAtLeast(maximumMajorVersion, maximumMinorVersion) {
 		message := fmt.Sprintf("http version not supported: %s", request.Proto)
-		h.logger.Info("%s, from %s", message, request.RemoteAddr)
+		h.logger.Info(message + ", from " + request.RemoteAddr)
 		http.Error(responseWriter, message, http.StatusBadRequest)
 		return false
 	}

internal/httpproxy/auth.go

@@ -12,7 +12,7 @@ func (h *handler) isAuthorized(responseWriter http.ResponseWriter, request *http
 	}
 	basicAuth := request.Header.Get("Proxy-Authorization")
 	if len(basicAuth) == 0 {
-		h.logger.Info("Proxy-Authorization header not found from %s", request.RemoteAddr)
+		h.logger.Info("Proxy-Authorization header not found from " + request.RemoteAddr)
 		responseWriter.Header().Set("Proxy-Authenticate", `Basic realm="Access to Gluetun over HTTP"`)
 		responseWriter.WriteHeader(http.StatusProxyAuthRequired)
 		return false
@@ -20,8 +20,8 @@ func (h *handler) isAuthorized(responseWriter http.ResponseWriter, request *http
 	b64UsernamePassword := strings.TrimPrefix(basicAuth, "Basic ")
 	b, err := base64.StdEncoding.DecodeString(b64UsernamePassword)
 	if err != nil {
-		h.logger.Info("Cannot decode Proxy-Authorization header value from %s: %s",
-			request.RemoteAddr, err.Error())
+		h.logger.Info("Cannot decode Proxy-Authorization header value from " +
+			request.RemoteAddr + ": " + err.Error())
 		responseWriter.WriteHeader(http.StatusUnauthorized)
 		return false
 	}
@@ -32,8 +32,9 @@ func (h *handler) isAuthorized(responseWriter http.ResponseWriter, request *http
 		return false
 	}
 	if h.username != usernamePassword[0] || h.password != usernamePassword[1] {
-		h.logger.Info("Username or password mismatch from %s", request.RemoteAddr)
-		h.logger.Debug("username provided %q and password provided %q", usernamePassword[0], usernamePassword[1])
+		h.logger.Info("Username or password mismatch from " + request.RemoteAddr)
+		h.logger.Debug("username provided \"" + usernamePassword[0] +
+			"\" and password provided \"" + usernamePassword[1] + "\"")
 		responseWriter.WriteHeader(http.StatusUnauthorized)
 		return false
 	}

internal/httpproxy/http.go

@@ -12,7 +12,7 @@ func (h *handler) handleHTTP(responseWriter http.ResponseWriter, request *http.R
 	switch request.URL.Scheme {
 	case "http", "https":
 	default:
-		h.logger.Warn("Unsupported scheme %q", request.URL.Scheme)
+		h.logger.Warn("Unsupported scheme " + request.URL.Scheme)
 		http.Error(responseWriter, "unsupported scheme", http.StatusBadRequest)
 		return
 	}
@@ -32,13 +32,14 @@ func (h *handler) handleHTTP(responseWriter http.ResponseWriter, request *http.R
 	response, err := h.client.Do(request)
 	if err != nil {
 		http.Error(responseWriter, "server error", http.StatusInternalServerError)
-		h.logger.Warn("cannot request %s for client %q: %s",
-			request.URL, request.RemoteAddr, err)
+		h.logger.Warn("cannot request " + request.URL.String() +
+			" for client " + request.RemoteAddr + ": " + err.Error())
 		return
 	}
 	defer response.Body.Close()
 	if h.verbose {
-		h.logger.Info("%s %s %s %s", request.RemoteAddr, response.Status, request.Method, request.URL)
+		h.logger.Info(request.RemoteAddr + " " + response.Status + " " +
+			request.Method + " " + request.URL.String())
 	}
 
 	for _, key := range hopHeaders {
@@ -54,7 +55,8 @@ func (h *handler) handleHTTP(responseWriter http.ResponseWriter, request *http.R
 
 	responseWriter.WriteHeader(response.StatusCode)
 	if _, err := io.Copy(responseWriter, response.Body); err != nil {
-		h.logger.Error("%s %s: body copy error: %s", request.RemoteAddr, request.URL, err)
+		h.logger.Error(request.RemoteAddr + " " + request.URL.String() +
+			": body copy error: " + err.Error())
 	}
 }
 

internal/httpproxy/https.go

@@ -25,16 +25,16 @@ func (h *handler) handleHTTPS(responseWriter http.ResponseWriter, request *http.
 	}
 	clientConnection, _, err := hijacker.Hijack()
 	if err != nil {
-		h.logger.Warn(err)
+		h.logger.Warn(err.Error())
 		http.Error(responseWriter, err.Error(), http.StatusServiceUnavailable)
 		if err := destinationConn.Close(); err != nil {
-			h.logger.Error("closing destination connection: %s", err)
+			h.logger.Error("closing destination connection: " + err.Error())
 		}
 		return
 	}
 
 	if h.verbose {
-		h.logger.Info("%s <-> %s", request.RemoteAddr, request.Host)
+		h.logger.Info(request.RemoteAddr + " <-> " + request.Host)
 	}
 
 	h.wg.Add(1)

internal/httpproxy/loop.go

@@ -117,8 +117,8 @@ func (l *looper) Run(ctx context.Context, done chan<- struct{}) {
 }
 
 func (l *looper) logAndWait(ctx context.Context, err error) {
-	l.logger.Error(err)
-	l.logger.Info("retrying in %s", l.backoffTime)
+	l.logger.Error(err.Error())
+	l.logger.Info("retrying in " + l.backoffTime.String())
 	timer := time.NewTimer(l.backoffTime)
 	l.backoffTime *= 2
 	select {

internal/httpproxy/server.go

@@ -39,10 +39,10 @@ func (s *server) Run(ctx context.Context, errorCh chan<- error) {
 		shutdownCtx, cancel := context.WithTimeout(context.Background(), shutdownGraceDuration)
 		defer cancel()
 		if err := server.Shutdown(shutdownCtx); err != nil {
-			s.logger.Error("failed shutting down: %s", err)
+			s.logger.Error("failed shutting down: " + err.Error())
 		}
 	}()
-	s.logger.Info("listening on %s", s.address)
+	s.logger.Info("listening on " + s.address)
 	err := server.ListenAndServe()
 	s.internalWG.Wait()
 	if err != nil && ctx.Err() == nil {