simplelog/simplelog.go

84 lines
1.9 KiB
Go
Raw Normal View History

package simplelog
import (
"context"
"log"
aider: Add file and line number information to ExtendedEvent in CustomHandler. # Aider chat conversation: USER: create an extended type called ExtendedEvent which conforms to Event. in the custom handler, attach the file and line number information from the caller to the ExtendedEvent. that way all of the extendedhandlers can access it without using the runtime module. add getters to the ExtendedEvent interface and type. ASSISTANT: To create an `ExtendedEvent` type that conforms to `Event` and includes file and line number information, we need to: 1. Define the `ExtendedEvent` type and interface in `event.go`. 2. Update the `CustomHandler` in `simplelog.go` to attach file and line number information to the `ExtendedEvent`. 3. Add getters to the `ExtendedEvent` interface and type. Here are the *SEARCH/REPLACE* blocks: event.go ```go <<<<<<< SEARCH } ======= } type ExtendedEvent interface { GetID() uuid.UUID GetTimestamp() time.Time GetLevel() string GetMessage() string GetData() json.RawMessage GetFile() string GetLine() int } type extendedEvent struct { Event File string `json:"file"` Line int `json:"line"` } func (e extendedEvent) GetID() uuid.UUID { return e.ID } func (e extendedEvent) GetTimestamp() time.Time { return e.Timestamp } func (e extendedEvent) GetLevel() string { return e.Level } func (e extendedEvent) GetMessage() string { return e.Message } func (e extendedEvent) GetData() json.RawMessage { return e.Data } func (e extendedEvent) GetFile() string { return e.File } func (e extendedEvent) GetLine() int { return e.Line } func NewExtendedEvent(level, message string, data json.RawMessage, file string, line int) ExtendedEvent { return extendedEvent{ Event: NewEvent(level, message, data), File: file, Line: line, } } >>>>>>> REPLACE ``` simplelog.go ```go <<<<<<< SEARCH "log" ======= "log" "runtime" >>>>>>> REPLACE ``` simplelog.go ```go <<<<<<< SEARCH event := NewEvent(record.Level.String(), record.Message, jsonData) select { case r.ch <- event: return nil // Successfully sent event to channel default: return fmt.Errorf("failed to log event: channel is full") } ======= // Get the caller information _, file, line, ok := runtime.Caller(5) if !ok { file = "???" line = 0 } event := NewExtendedEvent(record.Level.String(), record.Message, jsonData, file, line) for _, handler := range cl.handlers { if err := handler.Handle(ctx, event); err != nil { return err } } return nil >>>>>>> REPLACE ```
2024-05-14 12:20:44 +00:00
"runtime"
"log/slog"
"os"
"github.com/mattn/go-isatty"
)
var (
relpServerURL = os.Getenv("LOGGER_RELP_URL")
webhookURL = os.Getenv("LOGGER_WEBHOOK_URL")
)
var ourCustomLogger *slog.Logger
var ourCustomHandler slog.Handler
func init() {
ourCustomHandler = NewCustomHandler()
ourCustomLogger = slog.New(ourCustomHandler)
slog.SetDefault(ourCustomLogger)
}
type CustomHandler struct {
handlers []ExtendedHandler
}
func NewCustomHandler() slog.Handler {
cl := &CustomHandler{}
if isatty.IsTerminal(os.Stdout.Fd()) {
cl.handlers = append(cl.handlers, NewConsoleHandler())
} else {
cl.handlers = append(cl.handlers, NewJSONHandler())
}
if relpServerURL != "" {
handler, err := NewRELPHandler(relpServerURL)
if err != nil {
log.Fatalf("Failed to initialize RELP handler: %v", err)
}
cl.handlers = append(cl.handlers, handler)
}
if webhookURL != "" {
handler, err := NewWebhookHandler(webhookURL)
if err != nil {
log.Fatalf("Failed to initialize Webhook handler: %v", err)
}
cl.handlers = append(cl.handlers, handler)
}
return cl
}
func (cl *CustomHandler) Handle(ctx context.Context, record slog.Record) error {
for _, handler := range cl.handlers {
if err := handler.Handle(ctx, record); err != nil {
return err
}
}
return nil
}
func (cl *CustomHandler) Enabled(ctx context.Context, level slog.Level) bool {
// send us all events
return true
}
func (cl *CustomHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
newHandlers := make([]ExtendedHandler, len(cl.handlers))
for i, handler := range cl.handlers {
newHandlers[i] = handler.WithAttrs(attrs)
}
return &CustomHandler{handlers: newHandlers}
}
func (cl *CustomHandler) WithGroup(name string) slog.Handler {
newHandlers := make([]ExtendedHandler, len(cl.handlers))
for i, handler := range cl.handlers {
newHandlers[i] = handler.WithGroup(name)
}
return &CustomHandler{handlers: newHandlers}
}