Merge branch 'feat/notifyv2' into dev

Author: LumePart

src/logging/logging.go

@@ -7,10 +7,16 @@ import (
 )
 
 
-func Init(level string) {
-	handler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+func Init(level string, notifyClient NotificationClient) {
+	baseHandler := slog.NewTextHandler( os.Stdout, &slog.HandlerOptions{
 		Level: getLogLevel(level),
+		AddSource: true,
 	})
+
+	handler := &notifyHandler{
+		handler:   baseHandler,
+		notify: notifyClient,
+	}
 	logger := slog.New(handler)
 	slog.SetDefault(logger)
 }

src/logging/notify.go

@@ -0,0 +1,151 @@
+package logging
+
+import (
+	"context"
+	"encoding/json"
+	"explo/src/config"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"strings"
+
+	"github.com/nikoksr/notify"
+	"github.com/nikoksr/notify/service/discord"
+	nhttp "github.com/nikoksr/notify/service/http"
+	"github.com/nikoksr/notify/service/matrix"
+	"maunium.net/go/mautrix/id"
+)
+
+// TODO: reuse notifier instead of creating a new one every time. right now it's fine cause Explo sends 1 message per run
+
+
+type NotificationClient struct {
+	Cfg config.NotifyConfig
+}
+
+func InitNotify(cfg config.NotifyConfig) NotificationClient {
+	return NotificationClient{
+		Cfg: cfg,
+	}
+}
+
+func sendMatrix(cfg config.MatrixNotif, msg string) error {
+	// UserID and RoomID need to be cast as specific types
+	srvc, err := matrix.New(id.UserID(cfg.UserID), id.RoomID(cfg.RoomID), cfg.HomeServer, cfg.AccessToken)
+	if err != nil {
+    return fmt.Errorf("failed to create new Matrix notification service: %s", err.Error())
+  }
+
+  notifier := notify.New()
+  notifier.UseServices(srvc)
+
+  err = notifier.Send(context.Background(), "Explo", msg)
+  if err != nil {
+    return err
+  }
+
+  return nil
+}
+
+/* discordgo module (which notify uses) doesn't handle errors correctly
+ no errors are given even when authentication fails*/
+func sendDiscord(cfg config.DiscordNotif, msg string) error {
+	srvc := discord.New()
+	if err := srvc.AuthenticateWithBotToken(cfg.BotToken); err != nil {
+		return fmt.Errorf("failed to authenticate against Discord: %s", err.Error())
+	}
+
+	srvc.AddReceivers(cfg.ChannelIDs...)
+
+	notifier := notify.New()
+	notifier.UseServices(srvc)
+
+	if err := notifier.Send(context.Background(), "**Explo**", msg); err != nil {
+		return fmt.Errorf("failed to send Discord notification: %s", err.Error())
+	}
+
+	return nil	
+}
+
+func sendHttp(cfg config.HttpNotif, msg string) error {
+	httpNotify := nhttp.New()
+	webhooks := getNotifWebhooks(cfg.ReceiverURLs)
+
+	httpNotify.AddReceivers(webhooks...)
+	notifier := notify.NewWithServices(httpNotify)
+
+	if err := notifier.Send(context.Background(), "", msg); err != nil {
+		return fmt.Errorf("failed to send HTTP notification: %s", err.Error())
+	}
+	return nil
+}
+
+func getNotifWebhooks(urls []string) []*nhttp.Webhook{
+	var webhooks []*nhttp.Webhook
+
+	for _, url := range urls {
+
+		webhooks = append(webhooks, &nhttp.Webhook{
+			ContentType: "application/json",
+			URL: url,
+			Method: http.MethodPost,
+			BuildPayload: func(subject, message string) (payload any) {
+				payl := json.RawMessage(message)
+				return payl
+			},
+
+		})
+	}
+	return webhooks
+}
+
+// format notification for message client
+func formatRecordMsgClient(n Notification) string {
+	attrs := make([]string, 0, len(n.Attrs))
+
+	for k, v := range n.Attrs {
+		attrs = append(attrs, fmt.Sprintf("%s=%v", k, v))
+	}
+	return fmt.Sprintf(
+		"[%s] %s\n%s",
+		n.Level,
+		n.Message,
+		strings.Join(attrs, ", "),
+	)
+}
+
+func formatRecordJSON(n Notification) string {
+	nJSON, err := json.Marshal(n)
+	if err != nil {
+		slog.Error("failed to marshal notification", "err", err)
+	}
+	return string(nJSON)
+}
+
+
+func (c NotificationClient) SendNotification(n Notification) {
+	var err error
+	switch c.Cfg.Service {
+		case "matrix":
+			msg := formatRecordMsgClient(n)
+			err = sendMatrix(c.Cfg.Matrix, msg)
+		
+		case "discord":
+			msg := formatRecordMsgClient(n)
+			err = sendDiscord(c.Cfg.Discord, msg)
+
+		case "http":
+			msg := formatRecordJSON(n)
+			err = sendHttp(c.Cfg.Http, msg)
+		
+		case "": // no system defined
+			return
+		default:
+			err = fmt.Errorf("wrong system defined for notifications: %s", c.Cfg.Service)
+	}
+	if err != nil {
+		slog.Error(err.Error())
+	} else {
+		slog.Info("notification sent", "service", c.Cfg.Service)
+	}
+}

src/logging/notify_handler.go

@@ -0,0 +1,81 @@
+package logging
+
+import (
+	"log/slog"
+	"context"
+	"time"
+)
+// slog handler that checks whether to send notifications
+
+type notifyHandler struct {
+	handler   slog.Handler
+	notify NotificationClient
+}
+
+type Notification struct {
+	Time time.Time `json:"time"`
+	Level string `json:"level"`
+	Message string `json:"message"`
+	Attrs map[string]any `json:"attributes"`
+
+}
+
+func (h *notifyHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	return h.handler.Enabled(ctx, level)
+}
+
+func (h *notifyHandler) Handle(ctx context.Context, r slog.Record) error {
+	if shouldNotify(r) {
+		// send notification in another goroutine
+		notifyStruct := recordToStruct(r)
+		go h.notify.SendNotification(notifyStruct) 
+	}
+	return h.handler.Handle(ctx, r)
+}
+
+func (h *notifyHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return &notifyHandler{
+		handler:   h.handler.WithAttrs(attrs),
+		notify: h.notify,
+	}
+}
+
+func (h *notifyHandler) WithGroup(name string) slog.Handler {
+	return &notifyHandler{
+		handler:   h.handler.WithGroup(name),
+		notify: h.notify,
+	}
+}
+
+func shouldNotify(r slog.Record) bool {
+	notify := false
+
+	r.Attrs(func(a slog.Attr) bool {
+		if a.Key == "notify" && a.Value.Kind() == slog.KindBool && a.Value.Bool() {
+			notify = true
+			return false // stop scanning
+		}
+		return true
+	})
+
+	return notify
+}
+
+func recordToStruct(r slog.Record) Notification {
+	attrs := make(map[string]any, r.NumAttrs())
+
+	r.Attrs(func(a slog.Attr) bool {
+		// filter out notify control key
+		if a.Key != "notify" {
+			attrs[a.Key] = a.Value.Any()
+		}
+		return true
+	})
+
+	return Notification{
+		Time: r.Time,
+		Level:   r.Level.String(),
+		Message: r.Message,
+		Attrs:   attrs,
+	}
+}

src/main/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"explo/src/logging"
-	"fmt"
 	"log"
 	"log/slog"
 	"os"
@@ -29,7 +28,8 @@ func initHttpClient() *util.HttpClient {
 // Inits debug, gets playlist name, if needed, handles deprecation
 func setup(cfg *config.Config) {
 	cfg.HandleDeprecation()
-	logging.Init(cfg.LogLevel)
+	notifyClient := logging.InitNotify(cfg.NotifyCfg)
+	logging.Init(cfg.LogLevel, notifyClient)
 	cfg.GenPlaylistName()
 }
 
@@ -44,25 +44,21 @@ func main() {
 	slog.Info("Starting Explo...")
 
 	httpClient := initHttpClient()
-	notifyClient := logging.InitNotify(cfg.NotifyCfg)
 	client, err := client.NewClient(&cfg)
 	if err != nil {
 		slog.Error(err.Error())
-		notifyClient.SendNotification(err.Error())
 		os.Exit(1)
 	}
 	discovery := discovery.NewDiscoverer(cfg.DiscoveryCfg, httpClient)
 	downloader, err := downloader.NewDownloader(&cfg.DownloadCfg, httpClient, cfg.Flags.ExcludeLocal)
 	if err != nil {
 		slog.Error(err.Error())
-		notifyClient.SendNotification(err.Error())
 		os.Exit(1)
 	}
 
 	tracks, err := discovery.Discover()
 	if err != nil {
 		slog.Error(err.Error())
-		notifyClient.SendNotification(err.Error())
 		os.Exit(1)
 	}
 	if !cfg.Persist {
@@ -84,16 +80,13 @@ func main() {
 		downloader.StartDownload(&tracks)
 		if len(tracks) == 0 {
 			slog.Error("couldn't download any tracks")
-			notifyClient.SendNotification("couldn't download any tracks")
 			os.Exit(1)
 		}
 	}
 
 	if err := client.CreatePlaylist(tracks); err != nil {
 		slog.Warn(err.Error())
-		notifyClient.SendNotification(err.Error())
 	} else {
 		slog.Info("playlist created successfully", "system", cfg.System, "name", cfg.ClientCfg.PlaylistName)
-		notifyClient.SendNotification(fmt.Sprintf("%s playlist created in %s", cfg.ClientCfg.PlaylistName, cfg.System))
 	}
 }