Add sliceutils.ContainsFunc

Builder offers option to add extra fields to log messages

http/chain.go

@@ -1,4 +1,4 @@
-package http
+package webutils
 
 import (
 	"net/http"

http/context.go

@@ -1,4 +1,4 @@
-package http
+package webutils
 
 import (
 	"context"

http/httpErr.go

@@ -1,6 +1,7 @@
-package http
+package webutils
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 )
@@ -9,8 +10,63 @@ import (
 // The error will have the given return code `code`
 // and a json encoded body with the field "id" set to `errId`
 // and a field "message" set to the `message`
+//
+// Deprecated: Use ProblemDetails or ProblemDetailsStatusOnly instead
 func HttpErr(w http.ResponseWriter, errId int, message string, code int) {
 	w.WriteHeader(code)
 	w.Header().Add("Content-Type", "application/json")
 	fmt.Fprintf(w, "{\"id\": %d, \"message\": \"%s\"}", errId, message)
 }
+
+// Write an RFC 9457 compliant problem details response
+// If details is not nil, it will be included.
+// If extras is not nil, each key-value pair will be included at
+// the root layer.
+// Keys in extras that would overwrite the default elements will be ignored.
+// Those would be "type", "status", "title" and "detail"
+func ProblemDetails(
+	w http.ResponseWriter,
+	statusCode int,
+	errorType string,
+	errorTitle string,
+	details *string,
+	extras map[string]any,
+) {
+	w.Header().Add("Content-Type", "application/problem+json")
+	w.WriteHeader(statusCode)
+	data := map[string]any{
+		"type":   errorType,
+		"status": statusCode,
+		"title":  errorTitle,
+	}
+	if details != nil {
+		data["detail"] = *details
+	}
+	if extras != nil {
+		for k, v := range extras {
+			if _, ok := data[k]; ok {
+				// Don't overwrite default fields
+				continue
+			}
+			data[k] = v
+		}
+	}
+	enc := json.NewEncoder(w)
+	enc.Encode(data)
+}
+
+// Write a simple problem details response.
+// It only provides the status code, as defined in RFC 9457, section 4.2.1
+func ProblemDetailsStatusOnly(w http.ResponseWriter, statusCode int) {
+	w.Header().Add("Content-Type", "application/problem+json")
+	w.WriteHeader(statusCode)
+	data := map[string]any{
+		"type":      "about:blank",
+		"title":     http.StatusText(statusCode),
+		"status":    statusCode,
+		"reference": "RFC 9457",
+	}
+
+	enc := json.NewEncoder(w)
+	enc.Encode(data)
+}

http/json.go

@@ -0,0 +1,17 @@
+package webutils
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+func SendJson(w http.ResponseWriter, data any) error {
+	encoded, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+	w.Header().Add("Content-Type", "application/json")
+	fmt.Fprint(w, string(encoded))
+	return nil
+}

http/zerolog.go

@@ -1,4 +1,4 @@
-package http
+package webutils
 
 import (
 	"net/http"
@@ -9,6 +9,33 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+func BuildLoggingMiddleware(extras map[string]string) HandlerBuilder {
+	return func(h http.Handler) http.Handler {
+		return ChainMiddlewares(h,
+			hlog.NewHandler(log.Logger),
+			hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
+				if strings.HasPrefix(r.URL.Path, "/assets") {
+					return
+				}
+				logger := hlog.FromRequest(r).Info().
+					Str("method", r.Method).
+					Stringer("url", r.URL).
+					Int("status", status).
+					Int("size", size).
+					Dur("duration", duration)
+				for k, v := range extras {
+					logger = logger.Str(k, v)
+				}
+				logger.Send()
+			}),
+			hlog.RemoteAddrHandler("ip"),
+			hlog.UserAgentHandler("user_agent"),
+			hlog.RefererHandler("referer"),
+			hlog.RequestIDHandler("req_id", "Request-Id"),
+		)
+	}
+}
+
 func LoggingMiddleware(handler http.Handler) http.Handler {
 	return ChainMiddlewares(handler,
 		hlog.NewHandler(log.Logger),

math/math.go

@@ -0,0 +1,13 @@
+package mathutils
+
+type SignedNumber interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~float32 | ~float64
+}
+
+func Abs[T SignedNumber](num T) T {
+	if num > 0 {
+		return num
+	} else {
+		return num * -1
+	}
+}

other/zerolog.go

@@ -8,8 +8,6 @@ import (
 
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
-
-	"git.mstar.dev/mstar/goutils/logrotate"
 )
 
 var cliFlagLogLevel = "info"
@@ -30,13 +28,12 @@ func SetupFlags() {
 	)
 }
 
-// If logfileName != nil, that file will be used for writing logs to.
-// Additionally, this function will then return another function
-// for rotating the log file
-func ConfigureLogging(logfileName *string) func() error {
-	rotateFunc := configOutputs(logfileName)
+// Configure logging. Utilises the flags setup in [SetupFlags].
+// If logWriter is not nil, will also write logs, as json objects,
+// to the given writer
+func ConfigureLogging(logWriter io.Writer) {
+	configOutputs(logWriter)
 	configLevel()
-	return rotateFunc
 }
 
 func configLevel() {
@@ -59,20 +56,14 @@ func configLevel() {
 	log.Info().Str("new-level", cliFlagLogLevel).Msg("New logging level set")
 }
 
-func configOutputs(logfileName *string) (rotateLogs func() error) {
-	rotateLogs = func() error { return nil }
-	extraLogWriters := []io.Writer{}
-	if logfileName != nil {
-		logfile, err := logrotate.New(*logfileName)
-		if err != nil {
-			log.Fatal().Err(err).Msg("Failed to open log file")
-		}
-		extraLogWriters = append(extraLogWriters, logfile)
-		rotateLogs = logfile.Rotate
+func configOutputs(logWriter io.Writer) {
+	console := zerolog.ConsoleWriter{Out: os.Stderr}
+	extraLogWriters := []io.Writer{console}
+	if logWriter != nil {
+		extraLogWriters = append(extraLogWriters, logWriter)
 	}
 	if !cliFlagLogJson {
-		console := zerolog.ConsoleWriter{Out: os.Stderr}
-		log.Logger = zerolog.New(zerolog.MultiLevelWriter(append([]io.Writer{console}, extraLogWriters...)...)).
+		log.Logger = zerolog.New(zerolog.MultiLevelWriter(extraLogWriters...)).
 			With().
 			Timestamp().
 			Logger()

sliceutils/sliceUtils.go

@@ -81,6 +81,15 @@ func Contains[T comparable](a []T, b T) bool {
 	return false
 }
 
+func ContainsFunc[T any](a []T, f func(t T) bool) bool {
+	for _, v := range a {
+		if f(v) {
+			return true
+		}
+	}
+	return false
+}
+
 func Compact[T any](a []T, compactor func(acc T, next T) T) T {
 	var acc T
 	for _, v := range a {