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),

logrotate/logrotate.go

@@ -0,0 +1,67 @@
+// File wrapper for rotating log files
+// Copied from https://stackoverflow.com/a/28797984
+package logrotate
+
+import (
+	"os"
+	"path"
+	"sync"
+	"time"
+)
+
+type RotateWriter struct {
+	lock     sync.Mutex
+	filename string // should be set to the actual filename
+	fp       *os.File
+}
+
+// Make a new RotateWriter. Return nil if error occurs during setup.
+func New(filename string) (*RotateWriter, error) {
+	w := &RotateWriter{filename: filename}
+	err := w.Rotate()
+	if err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// Write satisfies the io.Writer interface.
+func (w *RotateWriter) Write(output []byte) (int, error) {
+	w.lock.Lock()
+	defer w.lock.Unlock()
+	return w.fp.Write(output)
+}
+
+// Perform the actual act of rotating and reopening file.
+func (w *RotateWriter) Rotate() (err error) {
+	w.lock.Lock()
+	defer w.lock.Unlock()
+
+	// Close existing file if open
+	if w.fp != nil {
+		err = w.fp.Close()
+		w.fp = nil
+		if err != nil {
+			return
+		}
+	}
+	// Rename dest file if it already exists
+	_, err = os.Stat(w.filename)
+	if err == nil {
+		err = os.Rename(w.filename, w.filename+"."+time.Now().Format(time.RFC3339))
+		if err != nil {
+			return
+		}
+	}
+
+	// Create a file.
+	dir := path.Dir(w.filename)
+	_, err = os.Stat(dir)
+	if err != nil {
+		if err = os.Mkdir(dir, os.ModeDir); err != nil {
+			return
+		}
+	}
+	w.fp, err = os.Create(w.filename)
+	return
+}

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

@@ -12,7 +12,6 @@ import (
 
 var cliFlagLogLevel = "info"
 var cliFlagLogJson = false
-var cliFlagLogFile = ""
 
 func SetupFlags() {
 	flag.StringVar(
@@ -27,16 +26,13 @@ func SetupFlags() {
 		false,
 		"Log json objects to stderr instead of nicely formatted ones",
 	)
-	flag.StringVar(
-		&cliFlagLogFile,
-		"logfile",
-		"",
-		"Set the file to write json formatted log messages to",
-	)
 }
 
-func ConfigureLoggingFromCliArgs() {
-	configOutputs()
+// 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()
 }
 
@@ -60,22 +56,14 @@ func configLevel() {
 	log.Info().Str("new-level", cliFlagLogLevel).Msg("New logging level set")
 }
 
-func configOutputs() {
-	extraLogWriters := []io.Writer{}
-	if cliFlagLogFile != "" {
-		file, err := os.OpenFile(cliFlagLogFile, os.O_APPEND|os.O_CREATE, os.ModeAppend)
-		if err != nil {
-			log.Fatal().Err(err).Msg("Failed to open log file")
-		}
-		// NOTE: Technically this leaks a file handle
-		// Shouldn't matter though since the log file should be open until the very end
-		// Sooooo, eh. Don't care about adding an elaborate system to close the file at the very end.
-		// OS will do that anyway
-		extraLogWriters = append(extraLogWriters, file)
+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()
@@ -84,4 +72,5 @@ func configOutputs() {
 			append([]io.Writer{log.Logger}, extraLogWriters...)...,
 		)).With().Timestamp().Logger()
 	}
+	return
 }

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 {