latest

# Aider chat conversation:

USER: rename CustomHandler to MultiplexHandler

ASSISTANT: Here are the necessary changes to rename `CustomHandler` to `MultiplexHandler`:

simplelog.go
```go
<<<<<<< SEARCH
	ourCustomHandler = NewCustomHandler()
=======
	ourCustomHandler = NewMultiplexHandler()
>>>>>>> REPLACE
```

simplelog.go
```go
<<<<<<< SEARCH
type CustomHandler struct {
=======
type MultiplexHandler struct {
>>>>>>> REPLACE
```

simplelog.go
```go
<<<<<<< SEARCH
func NewCustomHandler() slog.Handler {
	cl := &CustomHandler{}
=======
func NewMultiplexHandler() slog.Handler {
	cl := &MultiplexHandler{}
>>>>>>> REPLACE
```

simplelog.go
```go
<<<<<<< SEARCH
func (cl *CustomHandler) Handle(ctx context.Context, record slog.Record) error {
=======
func (cl *MultiplexHandler) Handle(ctx context.Context, record slog.Record) error {
>>>>>>> REPLACE
```

simplelog.go
```go
<<<<<<< SEARCH
func (cl *CustomHandler) Enabled(ctx context.Context, level slog.Level) bool {
=======
func (cl *MultiplexHandler) Enabled(ctx context.Context, level slog.Level) bool {
>>>>>>> REPLACE
```

simplelog.go
```go
<<<<<<< SEARCH
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}
=======
func (cl *MultiplexHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
	newHandlers := make([]ExtendedHandler, len(cl.handlers))
	for i, handler := range cl.handlers {
		newHandlers[i] = handler.WithAttrs(attrs)
	}
	return &MultiplexHandler{handlers: newHandlers}
}

func (cl *MultiplexHandler) WithGroup(name string) slog.Handler {
	newHandlers := make([]ExtendedHandler, len(cl.handlers))
	for i, handler := range cl.handlers {
		newHandlers[i] = handler.WithGroup(name)
	}
	return &MultiplexHandler{handlers: newHandlers}
>>>>>>> REPLACE
```

console_handler.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"runtime"
 	"time"
 
 	"github.com/fatih/color"
@@ -30,7 +31,13 @@ func (c *ConsoleHandler) Handle(ctx context.Context, record slog.Record) error {
 		colorFunc = color.New(color.FgWhite).SprintfFunc()
 	}
 
-	fmt.Println(colorFunc("%s [%s]: %s", timestamp, record.Level, record.Message))
+	// Get the caller information
+	_, file, line, ok := runtime.Caller(5)
+	if !ok {
+		file = "???"
+		line = 0
+	}
+	fmt.Println(colorFunc("%s [%s] %s:%d: %s", timestamp, record.Level, file, line, record.Message))
 	return nil
 }
 

event.go

@@ -15,6 +15,7 @@ type Event struct {
 	Data      json.RawMessage `json:"data"`
 }
 
+
 func NewEvent(level, message string, data json.RawMessage) Event {
 	return Event{
 		ID:        uuid.New(),

go.mod

@@ -1,4 +1,4 @@
-module git.eeqj.de/sneak/go-simplelog
+module sneak.berlin/go/simplelog
 
 go 1.22.1
 

handler.go

@@ -3,6 +3,6 @@ package simplelog
 import "log/slog"
 
 // Handler defines the interface for different log outputs.
-type Handler interface {
+type ExtendedHandler interface {
 	slog.Handler
 }

json_handler.go

@@ -1,13 +1,10 @@
 package simplelog
 
 import (
-	"context"
-	"encoding/json"
 	"context"
 	"encoding/json"
 	"log"
 	"log/slog"
-	"log"
 )
 
 type JSONHandler struct{}

relp_handler.go

@@ -10,8 +10,8 @@ import (
 	"net"
 	"net/url"
 	"os"
-	"os"
 	"path/filepath"
+	"runtime"
 	"strconv"
 	"time"
 
@@ -43,6 +43,8 @@ var (
 
 type RELPHandler struct {
 	relpServerURL string
+	relpHost      string
+	relpPort      string
 	conn          net.Conn
 	ch            chan Event
 	done          chan struct{}
@@ -50,51 +52,52 @@ type RELPHandler struct {
 	timer         *time.Timer
 }
 
-func NewRELPHandler(relpURL string) (*RELPHandler, error) {
+func NewRELPHandler(relpURL string) (ExtendedHandler, error) {
 	parsedURL, err := url.Parse(relpURL)
 	if err != nil {
-		return nil, fmt.Errorf("Error parsing RELP URL: %v", err)
+		return nil, fmt.Errorf("error parsing RELP URL: %v", err)
 	}
 	if parsedURL.Scheme != "tcp" {
-		return nil, fmt.Errorf("RELP URL must have the tcp scheme, got %s", parsedURL.Scheme)
+		return nil, fmt.Errorf("the RELP URL must have the tcp scheme, got %s", parsedURL.Scheme)
 	}
+
+	host, port, err := net.SplitHostPort(parsedURL.Host)
+	if err != nil {
+		return nil, fmt.Errorf("Error splitting host and port: %v", err)
+	}
+
 	if err := os.MkdirAll(filepath.Join(cacheDir, "simplelog"), 0755); err != nil {
-		return nil, fmt.Errorf("Failed to create cache directory: %v", err)
+		return nil, fmt.Errorf("failed to create cache directory: %v", err)
 	}
 	r := &RELPHandler{
-		relpServerURL: parsedURL.Host,
-		ch:            make(chan Event, diskBufferLimit),
-		done:          make(chan struct{}),
-		failedCh:      make(chan Event, diskBufferLimit),
-		timer:         time.NewTimer(diskWriteInterval),
+		ch:       make(chan Event, diskBufferLimit),
+		done:     make(chan struct{}),
+		failedCh: make(chan Event, diskBufferLimit),
+		timer:    time.NewTimer(diskWriteInterval),
+		relpHost: host,
+		relpPort: port,
 	}
 	if relpDebug {
 		log.Printf("Created new RELP handler for server at %s", r.relpServerURL)
 	}
+
+	err = r.Startup()
+	if err != nil {
+		return nil, err
+	}
 	return r, nil
 }
 
 func (r *RELPHandler) connectToRELPServer() (net.Conn, error) {
-	parsedURL, err := url.Parse(r.relpServerURL)
-	if err != nil {
-		return nil, fmt.Errorf("Error parsing RELP URL: %v", err)
-	}
-	if parsedURL.Scheme != "tcp" {
-		return nil, fmt.Errorf("RELP URL must have the tcp scheme, got %s", parsedURL.Scheme)
-	}
-	host, port, err := net.SplitHostPort(parsedURL.Host)
-	if err != nil {
-		return nil, fmt.Errorf("Error splitting host and port: %v", err)
-	}
-	conn, err := net.Dial("tcp", net.JoinHostPort(host, port))
+	conn, err := net.Dial("tcp", net.JoinHostPort(r.relpHost, r.relpPort))
 	if err != nil {
 		if relpDebug {
-			log.Printf("Failed to connect to RELP server at %s: %v", net.JoinHostPort(host, port), err)
+			log.Printf("Failed to connect to RELP server at %s: %v", net.JoinHostPort(r.relpHost, r.relpPort), err)
 		}
 		return nil, err
 	}
 	if relpDebug {
-		log.Printf("Successfully connected to RELP server at %s", net.JoinHostPort(host, port))
+		log.Printf("Successfully connected to RELP server at %s", net.JoinHostPort(r.relpHost, r.relpPort))
 	}
 	return conn, nil
 }
@@ -139,13 +142,20 @@ func (r *RELPHandler) Handle(ctx context.Context, record slog.Record) error {
 	if err != nil {
 		return fmt.Errorf("error marshaling attributes: %v", err)
 	}
-	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
 }
 
 func (r *RELPHandler) receiveEventsFromChannel() {

simplelog.go

@@ -3,12 +3,11 @@ package simplelog
 import (
 	"context"
 	"log"
+	"runtime"
 	"log/slog"
 	"os"
 
 	"github.com/mattn/go-isatty"
-
-	"github.com/mattn/go-isatty"
 )
 
 var (
@@ -16,53 +15,21 @@ var (
 	webhookURL    = os.Getenv("LOGGER_WEBHOOK_URL")
 )
 
-type CustomHandler struct {
-	handlers []slog.Handler
-}
-
-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 {
-	for _, handler := range cl.handlers {
-		if handler.Enabled(ctx, level) {
-			return true
-		}
-	}
-	return false
-}
-
-func (cl *CustomHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
-	newHandlers := make([]slog.Handler, 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([]slog.Handler, len(cl.handlers))
-	for i, handler := range cl.handlers {
-		newHandlers[i] = handler.WithGroup(name)
-	}
-	return &CustomHandler{handlers: newHandlers}
-}
-
 var ourCustomLogger *slog.Logger
+var ourCustomHandler slog.Handler
 
 func init() {
-	ourCustomLogger = NewCustomHandler()
+	ourCustomHandler = NewMultiplexHandler()
+	ourCustomLogger = slog.New(ourCustomHandler)
 	slog.SetDefault(ourCustomLogger)
 }
 
-func NewCustomHandler() *CustomHandler {
-	cl := &CustomHandler{}
+type MultiplexHandler struct {
+	handlers []ExtendedHandler
+}
+
+func NewMultiplexHandler() slog.Handler {
+	cl := &MultiplexHandler{}
 	if isatty.IsTerminal(os.Stdout.Fd()) {
 		cl.handlers = append(cl.handlers, NewConsoleHandler())
 	} else {
@@ -84,3 +51,84 @@ func NewCustomHandler() *CustomHandler {
 	}
 	return cl
 }
+
+func (cl *MultiplexHandler) 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 *MultiplexHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	// send us all events
+	return true
+}
+
+func (cl *MultiplexHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	newHandlers := make([]ExtendedHandler, len(cl.handlers))
+	for i, handler := range cl.handlers {
+		newHandlers[i] = handler.WithAttrs(attrs)
+	}
+	return &MultiplexHandler{handlers: newHandlers}
+}
+
+func (cl *MultiplexHandler) WithGroup(name string) slog.Handler {
+	newHandlers := make([]ExtendedHandler, len(cl.handlers))
+	for i, handler := range cl.handlers {
+		newHandlers[i] = handler.WithGroup(name)
+	}
+	return &MultiplexHandler{handlers: newHandlers}
+}
+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(baseEvent Event, file string, line int) ExtendedEvent {
+	return extendedEvent{
+		Event: baseEvent,
+		File:  file,
+		Line:  line,
+	}
+}

tools/run_relp_log_trial.sh

@@ -2,7 +2,7 @@
 
 # Set the environment variables for the RELP server URL and optionally for the webhook URL
 export LOGGER_RELP_URL="tcp://10.201.1.18:20514"
-export LOGGER_WEBHOOK_URL="https://example.com/webhook"
+#export LOGGER_WEBHOOK_URL="https://example.com/webhook"
 export RELP_DEBUG=1
 
 # Run the Go program