Mute unhelpful messages printed to log

Author: ecnepsnai

.github/dependabot.yml

@@ -4,3 +4,7 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/go.yml

@@ -13,12 +13,12 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@7884fcad6b5d53d10323aee724dc68d8b9096a2e # pin@v2
+      - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # pin@v3.1.0
 
       - name: Set up Go
-        uses: actions/setup-go@bfdd3570ce990073878bf10f6b2d79082de49492 # pin@v2
+        uses: actions/setup-go@268d8c0ca0432bb2cf416faae41297df9d262d7f # pin@v3.3.0
         with:
-          go-version: 1.19
+          go-version: 1.19.2
 
       - name: Build
         run: go build -v ./...

router/log.go

@@ -0,0 +1,35 @@
+package router
+
+import (
+	"bytes"
+
+	"github.com/ecnepsnai/logtic"
+)
+
+// mute the following unhelpful events from log lines
+
+var logMutePatterns = [][]byte{
+	[]byte("http: TLS handshake error from"),
+}
+
+type muteLogger struct {
+	source *logtic.Source
+	level  int
+}
+
+func (l muteLogger) Write(p []byte) (n int, err error) {
+	length := len(p)
+
+	mute := false
+	for _, pattern := range logMutePatterns {
+		if bytes.Contains(p, pattern) {
+			mute = true
+			break
+		}
+	}
+	if !mute {
+		l.source.Write(l.level, string(p[0:length-1]))
+	}
+
+	return len(p), nil
+}

router/log_test.go

@@ -0,0 +1,84 @@
+package router_test
+
+import (
+	"bytes"
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/tls"
+	"crypto/x509"
+	"math/big"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ecnepsnai/logtic"
+	"github.com/ecnepsnai/web/router"
+)
+
+func TestMuteLogger(t *testing.T) {
+	b := &bytes.Buffer{}
+	logtic.Log.Open()
+	logtic.Log.Level = logtic.LevelDebug
+	logtic.Log.Stdout = b
+	logtic.Log.Stderr = b
+
+	listenAddress := getListenAddress()
+
+	var pKey crypto.PrivateKey
+	var err error
+	pKey, err = ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+
+	pub := pKey.(crypto.Signer).Public()
+	tpl := &x509.Certificate{
+		SerialNumber:          &big.Int{},
+		NotBefore:             time.Now().UTC().AddDate(-100, 0, 0),
+		NotAfter:              time.Now().UTC().AddDate(100, 0, 0),
+		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment | x509.KeyUsageDataEncipherment,
+		BasicConstraintsValid: true,
+	}
+
+	certBytes, err := x509.CreateCertificate(rand.Reader, tpl, tpl, pub, pKey)
+	if err != nil {
+		panic(err)
+	}
+
+	l, err := tls.Listen("tcp", listenAddress, &tls.Config{
+		Certificates: []tls.Certificate{
+			{
+				Certificate: [][]byte{certBytes},
+				PrivateKey:  pKey,
+			},
+		},
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	server := router.New()
+	server.ServeFiles(t.TempDir(), "/")
+	go func() {
+		server.Serve(l)
+	}()
+	time.Sleep(5 * time.Millisecond)
+
+	c, err := net.Dial("tcp", listenAddress)
+	if err != nil {
+		panic(err)
+	}
+	if _, err := c.Write([]byte("")); err != nil {
+		panic(err)
+	}
+	c.Close()
+	time.Sleep(5 * time.Millisecond)
+
+	output := b.String()
+	if strings.Contains(output, "http: TLS handshake error from") {
+		t.Errorf("log output contains forbidden log events")
+	}
+}

router/server.go

@@ -1,6 +1,7 @@
 package router
 
 import (
+	golog "log"
 	"net"
 	"net/http"
 	"sync"
@@ -39,7 +40,10 @@ func New() *Server {
 		httpServer: &http.Server{
 			ReadTimeout:       5 * time.Minute,
 			ReadHeaderTimeout: 5 * time.Minute,
-			ErrorLog:          log.GoLogger(logtic.LevelError),
+			ErrorLog: golog.New(muteLogger{
+				source: log,
+				level:  logtic.LevelError,
+			}, "", 0),
 		},
 	}
 	return s
@@ -59,8 +63,6 @@ func (s *Server) ListenAndServe(addr string) error {
 		})
 		return err
 	}
-	s.listener = &l
-	s.httpServer.Handler = s.impl
 	s.impl.log.PDebug("Listen", map[string]interface{}{
 		"address": addr,
 	})
@@ -72,7 +74,9 @@ func (s *Server) ListenAndServe(addr string) error {
 // An error will only be returned if there was an error listening or the listener was abruptly closed.
 func (s *Server) Serve(listener net.Listener) error {
 	s.impl.log.Debug("Serve on listener")
-	return http.Serve(listener, s.impl)
+	s.httpServer.Handler = s.impl
+	s.listener = &listener
+	return s.httpServer.Serve(listener)
 }
 
 // Stop will stop the server. Server.ListenAndServe or Server.Serve will return net.ErrClosed. Does nothing if the