robinsiep / Go slog handlers

package log // HTTPError is used when the response of a HTTP request is unexpected or otherwise incorrect. type HTTPError interface { Error() string ReadBody() (string, error) StatusCode() int Close() error }

package log import ( "bytes" "context" "encoding/json" "fmt" "log/slog" "maps" "net/http" "net/url" "time" "github.com/pkg/errors" ) // SeqHandler is a slog.Handler that converts slog.Record instances into Seq events // and submits them to the specified Seq API. type SeqHandler struct { url url.URL apiKey string client http.Client enabledLevel slog.Level attrs []slog.Attr group string } // Enabled returns true if the given level is greater than or equal to the handler's enabled level // set during initialization. func (handler *SeqHandler) Enabled(_ context.Context, level slog.Level) bool { return level >= handler.enabledLevel } // Handle converts the given slog.Record into a Seq event and submits it to the Seq API. func (handler *SeqHandler) Handle(ctx context.Context, record slog.Record) error { event, err := handler.recordToSeqEvent(record) if err != nil { return err } return handler.postEvent(event) } func (handler *SeqHandler) recordToSeqEvent(record slog.Record) (map[string]any, error) { seqLevel, err := slogLevelToSeqLevel(record.Level) if err != nil { return map[string]any{}, err } event := map[string]any{ "@t": record.Time.Format(time.RFC3339Nano), "@l": seqLevel, "@m": record.Message, } eventAttrs := map[string]any{} record.Attrs(func(attr slog.Attr) bool { addAttr(eventAttrs, attr) return true }) for _, attr := range handler.attrs { addAttr(eventAttrs, attr) } if handler.group != "" { event[handler.group] = eventAttrs } else { maps.Copy(event, eventAttrs) } return event, nil } func (handler *SeqHandler) postEvent(event map[string]any) error { body, err := json.Marshal(event) if err != nil { return errors.Wrap(err, "failed to marshal event") } req, err := http.NewRequest("POST", handler.url.String(), bytes.NewReader(body)) if err != nil { return err } req.Header.Set("Content-Type", "application/json") if handler.apiKey != "" { req.Header.Set("X-Seq-ApiKey", handler.apiKey) } resp, err := handler.client.Do(req) if resp != nil { defer resp.Body.Close() } return err } // WithAttrs returns a new SeqHandler with the given attributes appended to the handler's existing attributes. func (handler *SeqHandler) WithAttrs(attrs []slog.Attr) *SeqHandler { return &SeqHandler{ url: handler.url, apiKey: handler.apiKey, client: handler.client, enabledLevel: handler.enabledLevel, attrs: append(handler.attrs, attrs...), group: handler.group, } } // WithGroup returns a new SeqHandler with the given log group name set. func (handler *SeqHandler) WithGroup(name string) *SeqHandler { if name == "" { return handler } return &SeqHandler{ url: handler.url, apiKey: handler.apiKey, client: handler.client, enabledLevel: handler.enabledLevel, attrs: handler.attrs, group: name, } } func slogLevelToSeqLevel(level slog.Level) (string, error) { switch level { case slog.LevelDebug: return "Debug", nil case slog.LevelInfo: return "Information", nil case slog.LevelWarn: return "Warning", nil case slog.LevelError: return "Error", nil default: return "", errors.Errorf("unknown slog level %s", level) } } func addAttr(event map[string]any, attr slog.Attr) { if attr.Key == "err" { if err, ok := attr.Value.Any().(error); ok { addErrorAttrs(event, err) return } } event[attr.Key] = attr.Value.Any() } func addErrorAttrs(event map[string]any, err error) { event["@x"] = fmt.Sprintf("%+v", err) httpError, ok := errors.Cause(err).(HTTPError) if ok { if responseBody, err := httpError.ReadBody(); err == nil { event["respBody"] = responseBody } } }

package log import ( "context" "fmt" "log/slog" "strings" "github.com/pkg/errors" ) const tab = "\t" const fourSpaces = " " // TextHandler is a slog.Handler that replaces all \t instances with four spaces and replaces errors with their // detailed string representation. type TextHandler struct { slog.Handler } // Handle replaces all \t instances with four spaces and replaces errors with their detailed string representation. func (handler *TextHandler) Handle(ctx context.Context, record slog.Record) error { record.Message = strings.ReplaceAll(record.Message, tab, fourSpaces) record = handler.parseRecordAttrs(record) return handler.Handler.Handle(ctx, record) } func (handler *TextHandler) parseRecordAttrs(record slog.Record) slog.Record { var attrs []slog.Attr record.Attrs(func(attr slog.Attr) bool { newAttrs := handler.parseAttr(attr) for _, newAttr := range newAttrs { attrs = append(attrs, *newAttr) } return true }) newRecord := slog.NewRecord(record.Time, record.Level, record.Message, record.PC) newRecord.AddAttrs(attrs...) return newRecord } func (handler *TextHandler) parseAttr(attr slog.Attr) []*slog.Attr { newAttrs := []*slog.Attr{&attr} attr.Value = attr.Value.Resolve() switch attr.Value.Kind() { case slog.KindString: attr.Value = slog.StringValue(strings.ReplaceAll(attr.Value.String(), tab, fourSpaces)) case slog.KindAny: if err, ok := attr.Value.Any().(error); ok { newAttrs = handler.parseErrorAttr(attr, err) } case slog.KindGroup: var groupAttrs []slog.Attr for _, groupAttr := range attr.Value.Group() { newGroupAttrs := handler.parseAttr(groupAttr) for _, newGroupAttr := range newGroupAttrs { groupAttrs = append(groupAttrs, *newGroupAttr) } } attr.Value = slog.GroupValue(groupAttrs...) } return newAttrs } func (handler *TextHandler) parseErrorAttr(attr slog.Attr, err error) []*slog.Attr { attr.Value = slog.StringValue(fmt.Sprintf("%+v", err)) newAttrs := handler.parseAttr(attr) httpError, ok := errors.Cause(err).(HTTPError) if ok { if responseBody, err := httpError.ReadBody(); err == nil { responseBodyAttr := slog.String("response body", responseBody) newAttrs = append(newAttrs, &responseBodyAttr) } } return newAttrs } // WithAttrs returns a new TextHandler with the given attributes appended to the handler's existing attributes. func (handler *TextHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return &TextHandler{handler.Handler.WithAttrs(attrs)} } // WithGroup returns a new TextHandler with the given group name set. func (handler *TextHandler) WithGroup(name string) slog.Handler { return &TextHandler{handler.Handler.WithGroup(name)} }