Add sliceutils.ContainsFunc

Builder offers option to add extra fields to log messages

go.mod

@@ -1,4 +1,4 @@
-module gitlab.com/mstarongitlab/goutils
+module git.mstar.dev/mstar/goutils
 
 go 1.19
 

http/chain.go

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

http/context.go

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

http/httpErr.go

@@ -0,0 +1,72 @@
+package webutils
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// Return an error over an http connection.
+// 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

@@ -0,0 +1,59 @@
+package webutils
+
+import (
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/rs/zerolog/hlog"
+	"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),
+		hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
+			if strings.HasPrefix(r.URL.Path, "/assets") {
+				return
+			}
+			hlog.FromRequest(r).Info().
+				Str("method", r.Method).
+				Stringer("url", r.URL).
+				Int("status", status).
+				Int("size", size).
+				Dur("duration", duration).
+				Send()
+		}),
+		hlog.RemoteAddrHandler("ip"),
+		hlog.UserAgentHandler("user_agent"),
+		hlog.RefererHandler("referer"),
+		hlog.RequestIDHandler("req_id", "Request-Id"),
+	)
+}

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
+}

maputils/mapUtils.go

@@ -1,6 +1,6 @@
 package maputils
 
-import "gitlab.com/mstarongitlab/goutils/sliceutils"
+import "git.mstar.dev/mstar/goutils/sliceutils"
 
 // MapSameKeys applies a given function to every key-value pair of a map.
 // The returned map's value type may be different from the type of the inital map's value
@@ -71,3 +71,15 @@ func CompareMap[K, V comparable](a, b map[K]V) bool {
 	}
 	return true
 }
+
+func Compact[K comparable, V any](
+	m map[K]V,
+	compactor func(accK K, accV V, nextK K, nextV V) (K, V),
+) (K, V) {
+	var accK K
+	var accV V
+	for k, v := range m {
+		accK, accV = compactor(accK, accV, k, v)
+	}
+	return accK, accV
+}

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
+	}
+}

middleware/zerolog.go

@@ -1,32 +0,0 @@
-package middleware
-
-import (
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/rs/zerolog/hlog"
-	"github.com/rs/zerolog/log"
-)
-
-func LoggingMiddleware(handler http.Handler) http.Handler {
-	return ChainMiddlewares(handler,
-		hlog.NewHandler(log.Logger),
-		hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
-			if strings.HasPrefix(r.URL.Path, "/assets") {
-				return
-			}
-			hlog.FromRequest(r).Info().
-				Str("method", r.Method).
-				Stringer("url", r.URL).
-				Int("status", status).
-				Int("size", size).
-				Dur("duration", duration).
-				Send()
-		}),
-		hlog.RemoteAddrHandler("ip"),
-		hlog.UserAgentHandler("user_agent"),
-		hlog.RefererHandler("referer"),
-		hlog.RequestIDHandler("req_id", "Request-Id"),
-	)
-}

other/httpErr.go

@@ -1,16 +0,0 @@
-package other
-
-import (
-	"fmt"
-	"net/http"
-)
-
-// Return an error over an http connection.
-// 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`
-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)
-}

other/other.go

@@ -1,5 +1,7 @@
 package other
 
+import "fmt"
+
 // OutputIntoChannel takes a singular return value and sends it into the target channel.
 // This is a wrapper for functions where a value can't be collected from directly.
 // Example: goroutines
@@ -7,6 +9,10 @@ func OutputIntoChannel[T any](out T, target chan T) {
 	target <- out
 }
 
+// Must is a quick wrapper to ensure that a function exits without error.
+// If err is not nil, it panics. Otherwise val is returned.
+// The intended use is something like Must(someFunc()), where someFunc
+// has the signature someFunc() (T, error), with T being whatever type needed
 func Must[T any](val T, err error) T {
 	if err != nil {
 		panic(err)
@@ -14,6 +20,13 @@ func Must[T any](val T, err error) T {
 	return val
 }
 
+// IntoPointer returns a pointer to the given value
 func IntoPointer[T any](val T) *T {
 	return &val
 }
+
+// Error formats error messages to follow a common convention of
+// "source: message: wrapped error"
+func Error(source, message string, err error) error {
+	return fmt.Errorf("%s: %s: %w", source, message, err)
+}

other/zerolog.go

@@ -0,0 +1,76 @@
+package other
+
+import (
+	"flag"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+)
+
+var cliFlagLogLevel = "info"
+var cliFlagLogJson = false
+
+func SetupFlags() {
+	flag.StringVar(
+		&cliFlagLogLevel,
+		"loglevel",
+		"info",
+		"Set the logging level. Valid values (case insensitive) are: debug, info, warn, error, fatal",
+	)
+	flag.BoolVar(
+		&cliFlagLogJson,
+		"logjson",
+		false,
+		"Log json objects to stderr instead of nicely formatted ones",
+	)
+}
+
+// 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()
+}
+
+func configLevel() {
+	switch strings.ToLower(cliFlagLogLevel) {
+	case "trace":
+		zerolog.SetGlobalLevel(zerolog.TraceLevel)
+	case "debug":
+		zerolog.SetGlobalLevel(zerolog.DebugLevel)
+	case "info":
+		zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	case "warn":
+		zerolog.SetGlobalLevel(zerolog.WarnLevel)
+	case "error":
+		zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	case "fatal":
+		zerolog.SetGlobalLevel(zerolog.FatalLevel)
+	default:
+		zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	}
+	log.Info().Str("new-level", cliFlagLogLevel).Msg("New logging level set")
+}
+
+func configOutputs(logWriter io.Writer) {
+	console := zerolog.ConsoleWriter{Out: os.Stderr}
+	extraLogWriters := []io.Writer{console}
+	if logWriter != nil {
+		extraLogWriters = append(extraLogWriters, logWriter)
+	}
+	if !cliFlagLogJson {
+		log.Logger = zerolog.New(zerolog.MultiLevelWriter(extraLogWriters...)).
+			With().
+			Timestamp().
+			Logger()
+	} else {
+		log.Logger = zerolog.New(zerolog.MultiLevelWriter(
+			append([]io.Writer{log.Logger}, extraLogWriters...)...,
+		)).With().Timestamp().Logger()
+	}
+	return
+}

sliceutils/sliceUtils.go

@@ -80,3 +80,20 @@ 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 {
+		acc = compactor(acc, v)
+	}
+	return acc
+}