Add per-handle option to not log events

Author: ecnepsnai

api.go

@@ -96,15 +96,15 @@ func (a API) apiPreHandle(endpointHandle APIHandle, options HandleOptions) route
 
 				options.UnauthorizedMethod(w, request.HTTP)
 			} else {
-				a.apiPostHandle(endpointHandle, userData)(w, request)
+				a.apiPostHandle(endpointHandle, userData, options)(w, request)
 			}
 			return
 		}
-		a.apiPostHandle(endpointHandle, nil)(w, request)
+		a.apiPostHandle(endpointHandle, nil, options)(w, request)
 	}
 }
 
-func (a API) apiPostHandle(endpointHandle APIHandle, userData interface{}) router.Handle {
+func (a API) apiPostHandle(endpointHandle APIHandle, userData interface{}, options HandleOptions) router.Handle {
 	return func(w http.ResponseWriter, r router.Request) {
 		w.Header().Set("Content-Type", "application/json")
 
@@ -143,13 +143,15 @@ func (a API) apiPostHandle(endpointHandle APIHandle, userData interface{}) route
 			response.Code = 200
 			response.Data = data
 		}
-		log.PWrite(a.server.Options.RequestLogLevel, "API Request", map[string]interface{}{
-			"remote_addr": getRealIP(r.HTTP),
-			"method":      r.HTTP.Method,
-			"url":         r.HTTP.URL,
-			"elapsed":     elapsed.String(),
-			"status":      response.Code,
-		})
+		if !options.DontLogRequests {
+			log.PWrite(a.server.Options.RequestLogLevel, "API Request", map[string]interface{}{
+				"remote_addr": getRealIP(r.HTTP),
+				"method":      r.HTTP.Method,
+				"url":         r.HTTP.URL,
+				"elapsed":     elapsed.String(),
+				"status":      response.Code,
+			})
+		}
 		if err := json.NewEncoder(w).Encode(response); err != nil {
 			log.PError("Error writing response", map[string]interface{}{
 				"method": r.HTTP.Method,

api_test.go

@@ -536,3 +536,65 @@ func TestAPILogLevel(t *testing.T) {
 		}
 	}
 }
+
+func TestAPIHandleNoLog(t *testing.T) {
+	logtic.Log.Reset()
+	logFilePath := path.Join(t.TempDir(), "web.log")
+	logtic.Log.FilePath = logFilePath
+
+	stdout := &bytes.Buffer{}
+	logtic.Log.Stdout = stdout
+	logtic.Log.Stderr = stdout
+
+	logtic.Log.Level = logtic.LevelDebug
+	logtic.Log.Open()
+	defer logtic.Log.Close()
+
+	server := newServer()
+
+	handle := func(request web.Request) (interface{}, *web.APIResponse, *web.Error) {
+		return true, nil, nil
+	}
+
+	path1 := randomString(5)
+	path2 := randomString(5)
+
+	server.API.GET("/"+path1, handle, web.HandleOptions{})
+	server.API.GET("/"+path2, handle, web.HandleOptions{DontLogRequests: true})
+
+	http.Get(fmt.Sprintf("http://localhost:%d/%s", server.ListenPort, path1))
+	http.Get(fmt.Sprintf("http://localhost:%d/%s", server.ListenPort, path2))
+
+	logtic.Log.Close()
+	path1Pattern := regexp.MustCompile(`[0-9\-:TZ]+ \[DEBUG\]\[HTTP\] API Request: elapsed='[^']+' method='GET' remote_addr='[^']+' status=200 url='/` + path1 + `'`)
+	path2Pattern := regexp.MustCompile(`[0-9\-:TZ]+ \[DEBUG\]\[HTTP\] API Request: elapsed='[^']+' method='GET' remote_addr='[^']+' status=200 url='/` + path2 + `'`)
+	f, err := os.OpenFile(logFilePath, os.O_RDONLY, 0644)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+
+	logFileData, err := io.ReadAll(f)
+	if err != nil {
+		panic(err)
+	}
+
+	if !path1Pattern.Match(logFileData) {
+		t.Errorf("Did not find expected log line for API request\n----\n%s\n----", logFileData)
+	}
+	if path2Pattern.Match(logFileData) {
+		t.Errorf("Did not find expected log line for API request\n----\n%s\n----", logFileData)
+	}
+
+	if stdout.Len() == 0 {
+		t.Errorf("Did not find expected log line in stdout for API request")
+	}
+
+	logtic.Log.Reset()
+	for _, arg := range os.Args {
+		if arg == "-test.v=true" {
+			logtic.Log.Level = logtic.LevelDebug
+			logtic.Log.Open()
+		}
+	}
+}

handle.go

@@ -32,6 +32,8 @@ type HandleOptions struct {
 	// exceed this limit will receive a 413 Payload Too Large response.
 	// The default value of 0 will not reject requests with large bodies.
 	MaxBodyLength uint64
+	// DontLogRequests if true then requests to this handle are not logged
+	DontLogRequests bool
 }
 
 func isUserdataNil(userData interface{}) bool {

http.go

@@ -104,11 +104,13 @@ func (h HTTP) httpPreHandle(endpointHandle HTTPHandle, options HandleOptions) ro
 			UserData:   userData,
 		})
 		elapsed := time.Since(start)
-		log.PWrite(h.server.Options.RequestLogLevel, "HTTP Request", map[string]interface{}{
-			"remote_addr": getRealIP(request.HTTP),
-			"method":      request.HTTP.Method,
-			"url":         request.HTTP.URL,
-			"elapsed":     elapsed.String(),
-		})
+		if !options.DontLogRequests {
+			log.PWrite(h.server.Options.RequestLogLevel, "HTTP Request", map[string]interface{}{
+				"remote_addr": getRealIP(request.HTTP),
+				"method":      request.HTTP.Method,
+				"url":         request.HTTP.URL,
+				"elapsed":     elapsed.String(),
+			})
+		}
 	}
 }

http_easy.go

@@ -132,15 +132,15 @@ func (h HTTPEasy) httpPreHandle(endpointHandle HTTPEasyHandle, options HandleOpt
 
 				options.UnauthorizedMethod(w, request.HTTP)
 			} else {
-				h.httpPostHandle(endpointHandle, userData)(w, request)
+				h.httpPostHandle(endpointHandle, userData, options)(w, request)
 			}
 			return
 		}
-		h.httpPostHandle(endpointHandle, nil)(w, request)
+		h.httpPostHandle(endpointHandle, nil, options)(w, request)
 	}
 }
 
-func (h HTTPEasy) httpPostHandle(endpointHandle HTTPEasyHandle, userData interface{}) router.Handle {
+func (h HTTPEasy) httpPostHandle(endpointHandle HTTPEasyHandle, userData interface{}, options HandleOptions) router.Handle {
 	return func(w http.ResponseWriter, r router.Request) {
 		request := Request{
 			HTTP:       r.HTTP,
@@ -206,13 +206,15 @@ func (h HTTPEasy) httpPostHandle(endpointHandle HTTPEasyHandle, userData interfa
 		if response.Status != 0 {
 			code = response.Status
 		}
-		log.PWrite(h.server.Options.RequestLogLevel, "HTTP Request", map[string]interface{}{
-			"remote_addr": getRealIP(r.HTTP),
-			"method":      r.HTTP.Method,
-			"url":         r.HTTP.URL,
-			"elapsed":     elapsed.String(),
-			"status":      code,
-		})
+		if !options.DontLogRequests {
+			log.PWrite(h.server.Options.RequestLogLevel, "HTTP Request", map[string]interface{}{
+				"remote_addr": getRealIP(r.HTTP),
+				"method":      r.HTTP.Method,
+				"url":         r.HTTP.URL,
+				"elapsed":     elapsed.String(),
+				"status":      code,
+			})
+		}
 		w.WriteHeader(code)
 
 		if r.HTTP.Method != "HEAD" && response.Reader != nil {

websocket.go

@@ -86,10 +86,12 @@ func (s *Server) socketHandler(endpointHandle SocketHandle, options HandleOption
 		}, &WSConn{
 			conn,
 		})
-		log.PWrite(s.Options.RequestLogLevel, "Websocket request", map[string]interface{}{
-			"method":      r.HTTP.Method,
-			"url":         r.HTTP.RequestURI,
-			"remote_addr": getRealIP(r.HTTP),
-		})
+		if !options.DontLogRequests {
+			log.PWrite(s.Options.RequestLogLevel, "Websocket request", map[string]interface{}{
+				"method":      r.HTTP.Method,
+				"url":         r.HTTP.RequestURI,
+				"remote_addr": getRealIP(r.HTTP),
+			})
+		}
 	}
 }