Skip access log entries if path is excluded

Author: g-w

helper.go

@@ -68,7 +68,11 @@ func SetWithConfig(level string, config *LogConfig) error {
 
 // Access logs an access entry with call duration and status code
 func Access(r *http.Request, start time.Time, statusCode int) {
-	e := access(r, start, statusCode, nil)
+	access(logrus.InfoLevel, r, start, statusCode)
+}
+
+func access(level logrus.Level, r *http.Request, start time.Time, statusCode int) {
+	e := createAccessEntry(r, start, statusCode, nil)
 
 	var msg string
 	if len(r.URL.RawQuery) == 0 {
@@ -77,17 +81,19 @@ func Access(r *http.Request, start time.Time, statusCode int) {
 		msg = fmt.Sprintf("%v ->%v %v?%s", statusCode, r.Method, r.URL.Path, r.URL.RawQuery)
 	}
 
+	e.Log(accessLogLevelFor(level, r, statusCode), msg)
+}
+
+func accessLogLevelFor(level logrus.Level, r *http.Request, statusCode int) logrus.Level {
 	if statusCode >= 200 && statusCode <= 399 {
 		if isHealthRequest(r) {
-			e.Debug(msg)
-		} else {
-			e.Info(msg)
+			return logrus.DebugLevel
 		}
+		return level
 	} else if statusCode >= 400 && statusCode <= 499 {
-		e.Warn(msg)
-	} else {
-		e.Error(msg)
+		return logrus.WarnLevel
 	}
+	return logrus.ErrorLevel
 }
 
 func isHealthRequest(r *http.Request) bool {
@@ -96,16 +102,16 @@ func isHealthRequest(r *http.Request) bool {
 
 // AccessError logs an error while accessing
 func AccessError(r *http.Request, start time.Time, err error) {
-	e := access(r, start, 0, err)
+	e := createAccessEntry(r, start, 0, err)
 	e.Errorf("ERROR ->%v %v", r.Method, r.URL.Path)
 }
 
 func AccessAborted(r *http.Request, start time.Time) {
-	e := access(r, start, 0, nil)
+	e := createAccessEntry(r, start, 0, nil)
 	e.Infof("ABORTED ->%v %v", r.Method, r.URL.Path)
 }
 
-func access(r *http.Request, start time.Time, statusCode int, err error) *Entry {
+func createAccessEntry(r *http.Request, start time.Time, statusCode int, err error) *Entry {
 	url := r.URL.Path
 	if r.URL.RawQuery != "" {
 		url += "?" + r.URL.RawQuery

log_middleware.go

@@ -4,22 +4,64 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"regexp"
 	"runtime"
 	"strings"
 	"time"
 
+	"github.com/sirupsen/logrus"
 	"github.com/snabble/go-logging/v2/tracex"
 )
 
+type LogMiddlewareConfig struct {
+	// SkipSuccessfulRequestsMatching is a list of go reqular
+	// expressions, the access log is skipped if for request where the
+	// request path matches the expression.
+	SkipSuccessfulRequestsMatching []string
+}
+
 type LogMiddleware struct {
 	Next http.Handler
+
+	skipCache []*regexp.Regexp
 }
 
 func NewLogMiddleware(next http.Handler) http.Handler {
+	handler, _ := AddLogMiddleware(next, LogMiddlewareConfig{})
+	return handler
+}
+
+func AddLogMiddleware(next http.Handler, cfg LogMiddlewareConfig) (http.Handler, error) {
+	skipCache, err := buildSkipCache(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	middleware := &LogMiddleware{
+		Next:      next,
+		skipCache: skipCache,
+	}
+
 	if Log.config.EnableTraces {
-		return tracex.NewHandler(&LogMiddleware{Next: next}, "common")
+		return tracex.NewHandler(middleware, "common"), nil
 	}
-	return &LogMiddleware{Next: next}
+
+	return middleware, nil
+}
+
+func buildSkipCache(cfg LogMiddlewareConfig) ([]*regexp.Regexp, error) {
+	var skipCache []*regexp.Regexp
+
+	for _, expr := range cfg.SkipSuccessfulRequestsMatching {
+		compiled, err := regexp.Compile(expr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid matcher: '%s': %w", expr, err)
+		}
+
+		skipCache = append(skipCache, compiled)
+	}
+
+	return skipCache, nil
 }
 
 func (mw *LogMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@@ -39,7 +81,21 @@ func (mw *LogMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	lrw := &logResponseWriter{ResponseWriter: w}
 	mw.Next.ServeHTTP(lrw, r)
 
-	Access(r, start, lrw.statusCode)
+	level := logrus.InfoLevel
+	if mw.isSkipped(r.URL.Path) {
+		level = logrus.DebugLevel
+	}
+
+	access(level, r, start, lrw.statusCode)
+}
+
+func (mw *LogMiddleware) isSkipped(path string) bool {
+	for _, exp := range mw.skipCache {
+		if exp.MatchString(path) {
+			return true
+		}
+	}
+	return false
 }
 
 // identifyLogOrigin returns the location, where a panic was raised

log_middleware_test.go

@@ -133,6 +133,43 @@ func Test_LogMiddleware_Log_implicit200(t *testing.T) {
 	a.Equal("info", data.Level)
 }
 
+func Test_LogMiddleware_Log_SkipSuccessfulRequestsMatching(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		url    string
+		code   int
+		logged bool
+	}{
+		{"skipped", "https://www.example.org/some/suffix", http.StatusOK, false},
+		{"status not ok", "https://www.example.org/some/suffix", http.StatusInternalServerError, true},
+		{"not matched", "https://www.example.org/some/other", http.StatusOK, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			logBuffer := bytes.NewBuffer(nil)
+			Log.Out = logBuffer
+
+			lm, err := AddLogMiddleware(
+				http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+					w.WriteHeader(test.code)
+					_, _ = w.Write([]byte("OK++"))
+				}),
+				LogMiddlewareConfig{
+					SkipSuccessfulRequestsMatching: []string{
+						"/suffix$",
+					},
+				},
+			)
+			require.NoError(t, err)
+
+			req, _ := http.NewRequest(http.MethodGet, test.url, nil)
+
+			lm.ServeHTTP(httptest.NewRecorder(), req)
+
+			assert.Equal(t, test.logged, logBuffer.Len() > 0)
+		})
+	}
+}
+
 func Test_LogMiddleware_Log_HealthRequestAreNotLogged(t *testing.T) {
 	tests := []struct {
 		name           string