Zerr

gen.go

@@ -0,0 +1,3 @@
+package main
+
+//go:generate go run gen_zerr.go

gen_zerr.go

@@ -0,0 +1,137 @@
+//go:build ignore
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"slices"
+	"strings"
+
+	"github.com/rs/zerolog"
+)
+
+var excludedMethods []string = []string{
+	// not propagated
+	"AnErr",
+	"Err",
+	"Discard",
+	"Enabled",
+	"GetCtx",
+	// handled manually
+	"Msg",
+	"MsgFunc",
+	"Msgf",
+	"Send",
+}
+
+func main() {
+	logger := zerolog.New(os.Stdout)
+	e := logger.Error()
+
+	r := reflect.TypeOf(e)
+	fmt.Println(r.NumMethod())
+
+	mes := []*Method{}
+	for i := range r.NumMethod() {
+		m := r.Method(i)
+		if slices.Contains(excludedMethods, m.Name) {
+			continue
+		}
+
+		me, _ := parseMethod(m)
+		// fmt.Printf("%+v\n", me)
+		mes = append(mes, me)
+	}
+
+	f, err := os.Create("./internal/errors/zerr.go")
+	if err != nil {
+		panic(err.Error())
+	}
+	defer f.Close()
+
+	f.WriteString("package errors\n")
+
+	for _, me := range mes {
+		fmt.Println(me.RequiredImports)
+		ins := []string{}
+		for i, pn := range me.ParameterNames {
+			ins = append(ins, fmt.Sprintf("%s %s", pn, me.ParameterTypes[i]))
+		}
+		f.WriteString(fmt.Sprintf(methodProto, me.Name, strings.Join(ins, ", "), strings.Join(me.ParameterNames, ", ")))
+	}
+
+}
+
+type Method struct {
+	Name            string
+	ParameterNames  []string
+	ParameterTypes  []string
+	RequiredImports []string
+}
+
+var methodProto = `
+func (err *Error) %[1]s(%[2]s) *Error {
+    err.e.%[1]s(%[3]s)
+	return err
+}
+`
+
+var moduleProto = `
+package errors
+
+import (
+%s
+)
+
+%s
+`
+
+func parseMethod(m reflect.Method) (*Method, error) {
+	if m.Type.NumOut() != 1 {
+		// FIXME panic if return type of method is not *zerolog.Event
+		//  || m.Type.Out(0) != nil
+		return nil, errors.New("oops")
+	}
+
+	ni := m.Type.NumIn() - 1
+
+	var pns []string
+	switch ni {
+	case 0:
+	case 1:
+		pns = append(pns, "value")
+	case 2:
+		pns = append(pns, "key", "value")
+	default:
+		pns = append(pns, "key")
+		for i := range ni - 1 {
+			pns = append(pns, fmt.Sprintf("value%d", i+1))
+		}
+	}
+
+	pts := []string{}
+	ris := []string{}
+	for i := range ni {
+		in := m.Type.In(i + 1)
+		pts = append(pts, in.Name())
+		if ri := in.PkgPath(); ri != "" {
+			ris = append(ris, ri)
+		}
+	}
+
+	// b := strings.Builder{}
+	// b.WriteString(fmt.Sprintf("func (err *zerr.Error) %s() *zerr.Error {}", m.Name))
+	// return b.String()
+	// m.Func.FieldByIndex([]int{0})
+
+	// return fmt.Sprint(m.Name, "  ", m.Type)
+
+	return &Method{Name: m.Name, ParameterNames: pns, ParameterTypes: pts, RequiredImports: slices.Compact(ris)}, nil
+}
+
+func Foo(string, int) {
+
+}

http/http.go

@@ -3,14 +3,13 @@ package http
 import (
 	"crypto/tls"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 	"time"
 
 	"github.com/pmeier/redgiant"
+	"github.com/pmeier/redgiant/internal/errors"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 )
@@ -34,18 +33,17 @@ func NewRedgiant(host string, port uint, opts ...redgiant.OptFunc) *Redgiant {
 	return &Redgiant{host: fmt.Sprintf("%s:%d", host, port), c: o.HTTPClient, log: o.Logger}
 }
 
-func assertResponseSuccessful(r *http.Response) error {
+func assertRequestSuccessful(r *http.Response) *errors.Error {
 	if r.StatusCode >= 200 && r.StatusCode < 300 {
 		return nil
 	}
 
-	var msg string
-	if c, _ := io.ReadAll(r.Body); len(c) == 0 {
-		msg = r.Status
-	} else {
-		msg = string(c)
-	}
-	return errors.New(msg)
+	err := errors.New("request failed").HTTPRedacted(false)
+	// Int("code", r.StatusCode)
+	// if c, _ := io.ReadAll(r.Body); len(c) == 0 {
+	// 	err.Bytes("content", c)
+	// }
+	return err
 }
 
 func (rg *Redgiant) Health() error {
@@ -57,7 +55,7 @@ func (rg *Redgiant) Health() error {
 	}
 	defer r.Body.Close()
 
-	return assertResponseSuccessful(r)
+	return assertRequestSuccessful(r)
 }
 
 func (rg *Redgiant) getAPI(endpoint string, query url.Values, v any) error {
@@ -73,7 +71,7 @@ func (rg *Redgiant) getAPI(endpoint string, query url.Values, v any) error {
 	}
 	defer r.Body.Close()
 
-	if err := assertResponseSuccessful(r); err != nil {
+	if err := assertRequestSuccessful(r); err != nil {
 		return err
 	}
 

internal/errors/errors.go

@@ -0,0 +1,42 @@
+package errors
+
+import (
+	"bytes"
+	"net/http"
+
+	"github.com/rs/zerolog"
+)
+
+type Error struct {
+	StatusCode int
+	Redacted   bool
+	e          *zerolog.Event
+	msg        string
+	b          *bytes.Buffer
+	text       string
+}
+
+func New(msg string) *Error {
+	var b bytes.Buffer
+	l := zerolog.New(&b)
+	return &Error{StatusCode: http.StatusInternalServerError, Redacted: true, e: l.Log(), msg: msg, b: &b}
+}
+
+func (e *Error) Error() string {
+	if e.text == "" {
+		e.e.Msg(e.msg)
+		e.text = e.b.String()
+	}
+
+	return e.text
+}
+
+func (err *Error) HTTPStatusCode(statusCode int) *Error {
+	err.StatusCode = statusCode
+	return err
+}
+
+func (err *Error) HTTPRedacted(redacted bool) *Error {
+	err.Redacted = redacted
+	return err
+}