Logging: add support for additional logger filters other than hostname

caddyconfig/httpcaddyfile/builtins.go

@@ -910,7 +910,7 @@ func parseLogHelper(h Helper, globalLogNames map[string]struct{}) ([]ConfigValue
 	// this is useful for setting up loggers per subdomain in a site block
 	// with a wildcard domain
 	customHostnames := []string{}
-
+	noLoggerNames := false
 	for h.NextBlock(0) {
 		switch h.Val() {
 		case "hostnames":
@@ -995,6 +995,8 @@ func parseLogHelper(h Helper, globalLogNames map[string]struct{}) ([]ConfigValue
 			for h.NextArg() {
 				cl.Exclude = append(cl.Exclude, h.Val())
 			}
+		case "no_host_name":
+			noLoggerNames = true
 
 		default:
 			return nil, h.Errf("unrecognized subdirective: %s", h.Val())
@@ -1003,7 +1005,7 @@ func parseLogHelper(h Helper, globalLogNames map[string]struct{}) ([]ConfigValue
 
 	var val namedCustomLog
 	val.hostnames = customHostnames
-
+	val.noLoggerNames = noLoggerNames
 	isEmptyConfig := reflect.DeepEqual(cl, new(caddy.CustomLog))
 
 	// Skip handling of empty logging configs

caddyconfig/httpcaddyfile/httptype.go

@@ -794,6 +794,9 @@ func (st *ServerType) serversFromPairings(
 			sblockLogHosts := sblock.hostsFromKeys(true)
 			for _, cval := range sblock.pile["custom_log"] {
 				ncl := cval.Value.(namedCustomLog)
+				if ncl.noLoggerNames {
+					continue
+				}
 				if sblock.hasHostCatchAllKey() && len(ncl.hostnames) == 0 {
 					// all requests for hosts not able to be listed should use
 					// this log because it's a catch-all-hosts server block
@@ -1580,9 +1583,10 @@ func (c counter) nextGroup() string {
 }
 
 type namedCustomLog struct {
-	name      string
-	hostnames []string
-	log       *caddy.CustomLog
+	name          string
+	hostnames     []string
+	log           *caddy.CustomLog
+	noLoggerNames bool
 }
 
 // sbAddrAssociation is a mapping from a list of

caddytest/integration/caddyfile_adapt/log_filter_with_header.txt

@@ -0,0 +1,129 @@
+localhost {
+    log {
+		output file ./caddy.access.log
+	}
+	log health_check_log {
+		output file ./caddy.access.health.log
+		no_host_name
+	}
+	@healthCheck `header_regexp('User-Agent', '^some-regexp$') || path('/healthz*')`
+	handle @healthCheck {
+		vars access_logger_name health_check_log
+		respond "Healthy"
+	}
+
+	handle {
+		respond "Hello World"
+	}
+}
+----------
+{
+	"logging": {
+		"logs": {
+			"default": {
+				"exclude": [
+					"http.log.access.health_check_log",
+					"http.log.access.log0"
+				]
+			},
+			"health_check_log": {
+				"writer": {
+					"filename": "./caddy.access.health.log",
+					"output": "file"
+				},
+				"include": [
+					"http.log.access.health_check_log"
+				]
+			},
+			"log0": {
+				"writer": {
+					"filename": "./caddy.access.log",
+					"output": "file"
+				},
+				"include": [
+					"http.log.access.log0"
+				]
+			}
+		}
+	},
+	"apps": {
+		"http": {
+			"servers": {
+				"srv0": {
+					"listen": [
+						":443"
+					],
+					"routes": [
+						{
+							"match": [
+								{
+									"host": [
+										"localhost"
+									]
+								}
+							],
+							"handle": [
+								{
+									"handler": "subroute",
+									"routes": [
+										{
+											"group": "group2",
+											"handle": [
+												{
+													"handler": "subroute",
+													"routes": [
+														{
+															"handle": [
+																{
+																	"access_logger_name": "health_check_log",
+																	"handler": "vars"
+																},
+																{
+																	"body": "Healthy",
+																	"handler": "static_response"
+																}
+															]
+														}
+													]
+												}
+											],
+											"match": [
+												{
+													"expression": "header_regexp('User-Agent', '^some-regexp$') || path('/healthz*')"
+												}
+											]
+										},
+										{
+											"group": "group2",
+											"handle": [
+												{
+													"handler": "subroute",
+													"routes": [
+														{
+															"handle": [
+																{
+																	"body": "Hello World",
+																	"handler": "static_response"
+																}
+															]
+														}
+													]
+												}
+											]
+										}
+									]
+								}
+							],
+							"terminal": true
+						}
+					],
+					"logs": {
+						"logger_names": {
+							"localhost": "log0"
+						}
+					}
+				}
+			}
+		}
+	}
+}

modules/caddyhttp/logging.go

@@ -58,8 +58,11 @@ type ServerLogConfig struct {
 }
 
 // wrapLogger wraps logger in a logger named according to user preferences for the given host.
-func (slc ServerLogConfig) wrapLogger(logger *zap.Logger, host string) *zap.Logger {
-	if loggerName := slc.getLoggerName(host); loggerName != "" {
+func (slc ServerLogConfig) wrapLogger(logger *zap.Logger, req *http.Request) *zap.Logger {
+	if access_logger_name := GetVar(req.Context(), "access_logger_name"); access_logger_name != nil {
+		return logger.Named(access_logger_name.(string))
+	}
+	if loggerName := slc.getLoggerName(req.Host); loggerName != "" {
 		return logger.Named(loggerName)
 	}
 	return logger

modules/caddyhttp/server.go

@@ -368,10 +368,6 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	// prepare the error log
 	logger := errLog
-	if s.Logs != nil {
-		logger = s.Logs.wrapLogger(logger, r.Host)
-	}
-	logger = logger.With(zap.Duration("duration", duration))
 
 	// get the values that will be used to log the error
 	errStatus, errMsg, errFields := errLogValues(err)
@@ -382,6 +378,11 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if s.Errors != nil && len(s.Errors.Routes) > 0 {
 		// execute user-defined error handling route
 		err2 := s.errorHandlerChain.ServeHTTP(w, r)
+		if s.Logs != nil {
+			logger = s.Logs.wrapLogger(logger, r)
+		}
+		logger = logger.With(zap.Duration("duration", duration))
+
 		if err2 == nil {
 			// user's error route handled the error response
 			// successfully, so now just log the error
@@ -718,7 +719,7 @@ func (s *Server) logRequest(
 
 	logger := accLog
 	if s.Logs != nil {
-		logger = s.Logs.wrapLogger(logger, r.Host)
+		logger = s.Logs.wrapLogger(logger, r)
 	}
 
 	log := logger.Info