refactor(events,errors): simplified errors in events

2024-09-02 17:40:11 -03:00
parent 034fd9e905
commit a84d6dabfd
5 changed files with 212 additions and 236 deletions
--- a/internals/discord/bot/errors/errors.go
+++ b/internals/discord/bot/errors/errors.go
@@ -1,105 +1,127 @@
 package errors

 import (
+	"errors"
 	"fmt"
 	"log/slog"
+	"reflect"
 	"strings"

 	dgo "github.com/bwmarrin/discordgo"
 )

-type Error interface {
-	Log(*slog.Logger)
-	Reply(*dgo.Session, *dgo.Message)
-	LogReply(*slog.Logger, *dgo.Session, *dgo.Message)
+type BotError interface {
 	Error() string
 }

-type defaultError struct {
-	err  string
-	args []slog.Attr
+type BotErrorHandler interface {
+	Info() string
+	Error() string
+	Reply(s *dgo.Session, m *dgo.Message) BotErrorHandler
+	Send(s *dgo.Session, channelID string) BotErrorHandler
+	Log(l *slog.Logger) BotErrorHandler
 }

-func NewError(err string, args ...slog.Attr) defaultError {
-	return defaultError{err, args}
+type defaultErrHandler struct {
+	BotError
 }

-func New(err string, args ...slog.Attr) defaultError {
-	return NewError(err, args...)
+func (err *defaultErrHandler) Error() string {
+	return err.Error()
 }

-func (err defaultError) Log(l *slog.Logger) {
-	args := make([]any, len(err.args))
-	for i, a := range err.args {
-		args[i] = any(a)
-	}
-	l.Error(err.err, args...)
+func (err *defaultErrHandler) Info() string {
+	return err.Info()
 }

-func (err defaultError) Reply(s *dgo.Session, m *dgo.Message) {
-	_, erro := s.ChannelMessageSendReply(
-		m.ChannelID,
-		fmt.Sprintf("Error: %s\nSee logs for more details", err.err),
-		m.Reference(),
-	)
-	if erro != nil {
-		_, _ = s.ChannelMessageSendReply(
+func (err *defaultErrHandler) Reply(s *dgo.Session, m *dgo.Message) BotErrorHandler {
+	if _, erro := s.ChannelMessageSendReply(m.ChannelID, err.Error(), m.Reference()); erro != nil {
+		s.ChannelMessageSend(
 			m.ChannelID,
-			fmt.Sprintf("Failed to send error message (somehow), due to:\n%s", erro.Error()),
-			m.Reference(),
+			fmt.Sprintf(
+				"Failed to reply message %s due to \"%s\" with error: %s.",
+				m.ID,
+				erro.Error(),
+				err.Error(),
+			),
 		)
 	}
+	return err
 }

-func (err defaultError) Send(s *dgo.Session, channelID string) {
-	_, erro := s.ChannelMessageSend(
-		channelID,
-		fmt.Sprintf("Error: %s\nSee logs for more details", err.err),
-	)
-	if erro != nil {
+func (err *defaultErrHandler) Send(s *dgo.Session, channelID string) BotErrorHandler {
+	if _, erro := s.ChannelMessageSend(channelID, err.Error()); erro != nil {
 		_, _ = s.ChannelMessageSend(
 			channelID,
-			fmt.Sprintf("Failed to send error message (somehow), due to:\n%s", erro.Error()),
+			fmt.Sprintf(
+				"Failed to send error message due to \"%s\" with error: %s.",
+				erro.Error(),
+				err.Error(),
+			),
 		)
 	}
+	return err
 }

-func (err defaultError) LogReply(l *slog.Logger, s *dgo.Session, m *dgo.Message) {
-	err.Reply(s, m)
-	err.Log(l)
+func (err *defaultErrHandler) Log(l *slog.Logger) BotErrorHandler {
+	l.Error(err.Error())
+	return err
 }

-func (err defaultError) LogSend(l *slog.Logger, s *dgo.Session, channelID string) {
-	err.Send(s, channelID)
-	err.Log(l)
+type EventError[E any] struct {
+	data   map[string]any
+	errors []error
 }

-func (err defaultError) Error() string {
-	s := make([]string, len(err.args))
-	for i, a := range err.args {
-		s[i] = fmt.Sprintf("%s=%s", a.Key, a.Value)
+func NewEventError[E any](data map[string]any, err ...error) *EventError[E] {
+	return &EventError[E]{data, err}
+}
+
+func (h *EventError[E]) Wrap(err ...error) *EventError[E] {
+	h.errors = append(h.errors, errors.Join(err...))
+	return h
+}
+
+func (h *EventError[E]) Wrapf(format string, a ...any) *EventError[E] {
+	h.errors = append(h.errors, fmt.Errorf(format, a...))
+	return h
+}
+
+func (h *EventError[E]) AddData(key string, value any) *EventError[E] {
+	h.data[key] = value
+	return h
+}
+
+func (h *EventError[E]) Error() string {
+	var ev E
+	var name string
+	if t := reflect.TypeOf(ev); t != nil {
+		if n := t.Name(); n != "" {
+			name = strings.ToUpper(n)
+		} else {
+			name = "UNAMED EVENT"
+		}
+	} else {
+		name = "UNAMED EVENT"
 	}
-	return fmt.Sprintf("%s\n%s", err.err, strings.Join(s, " "))
+	err := errors.Join(h.errors...)
+	return errors.Join(fmt.Errorf("Failed to process event %s", name), err).Error()
 }

-type ErrDatabase struct {
-	defaultError
+func (h *EventError[E]) Log(l *slog.Logger) *EventError[E] {
+	dh := &defaultErrHandler{h}
+	dh.Log(l)
+	return h
 }

-func NewErrDatabase(args ...slog.Attr) ErrDatabase {
-	return ErrDatabase{defaultError{
-		"Error while trying to talk to the database.",
-		args,
-	}}
+func (h *EventError[E]) Reply(s *dgo.Session, r *dgo.Message) *EventError[E] {
+	dh := &defaultErrHandler{h}
+	dh.Reply(s, r)
+	return h
 }

-type ErrUserWebhook struct {
-	defaultError
-}
-
-func NewErrUserWebhook(args ...slog.Attr) ErrUserWebhook {
-	return ErrUserWebhook{defaultError{
-		"Error while trying to access/execute the user webhook",
-		args,
-	}}
+func (h *EventError[E]) Send(s *dgo.Session, channelID string) *EventError[E] {
+	dh := &defaultErrHandler{h}
+	dh.Send(s, channelID)
+	return h
 }
--- a/internals/discord/bot/events.go
+++ b/internals/discord/bot/events.go
@@ -6,7 +6,7 @@ func (b *Bot) registerEventHandlers() {
 	ehs := []any{
 		events.NewGuildCreate(b.logger, b.db).Serve,
 		events.NewMessageCreate(b.db, b.translator).Serve,
-		events.NewMessageEdit(b.db, b.translator).Serve,
+		events.NewMessageUpdate(b.db, b.translator).Serve,
 		events.NewMessageDelete(b.db).Serve,
 		events.NewReady(b.logger, b.db).Serve,
 		events.NewThreadCreate(b.db, b.translator).Serve,
--- a/internals/discord/bot/events/guild.go
+++ b/internals/discord/bot/events/guild.go
@@ -1,10 +1,11 @@
 package events

 import (
-	"errors"
+	"dislate/internals/discord/bot/errors"
+	"dislate/internals/discord/bot/gconf"
+	e "errors"
 	"log/slog"

-	"dislate/internals/discord/bot/gconf"
 	gdb "dislate/internals/guilddb"

 	dgo "github.com/bwmarrin/discordgo"
@@ -19,18 +20,19 @@ func NewGuildCreate(log *slog.Logger, db gconf.DB) GuildCreate {
 	return GuildCreate{log, db}
 }

-func (h GuildCreate) Serve(s *dgo.Session, e *dgo.GuildCreate) {
-	err := h.db.GuildInsert(gdb.Guild[gconf.ConfigString]{ID: e.Guild.ID})
+func (h GuildCreate) Serve(s *dgo.Session, ev *dgo.GuildCreate) {
+	err := h.db.GuildInsert(gdb.Guild[gconf.ConfigString]{ID: ev.Guild.ID})

-	if err != nil && !errors.Is(err, gdb.ErrNoAffect) {
-		h.log.Error("Failed to add guild to database",
-			slog.String("id", e.Guild.ID),
-			slog.String("err", err.Error()),
-		)
+	evErr := errors.NewEventError[GuildCreate](map[string]any{
+		"GuildID": ev.Guild.ID,
+	})
+
+	if err != nil && !e.Is(err, gdb.ErrNoAffect) {
+		evErr.Wrapf("Failed to add guild to database", err).Log(h.log)
 	} else if err != nil {
-		h.log.Info("Guild already in database", slog.String("id", e.Guild.ID))
+		h.log.Info("Guild already in database", slog.String("id", ev.Guild.ID))
 	} else {
-		h.log.Info("Added guild", slog.String("id", e.Guild.ID))
+		h.log.Info("Added guild", slog.String("id", ev.Guild.ID))
 	}
 }

@@ -43,15 +45,14 @@ func NewReady(log *slog.Logger, db gconf.DB) EventHandler[*dgo.Ready] {
 	return Ready{log, db}
 }

-func (h Ready) Serve(s *dgo.Session, e *dgo.Ready) {
-	for _, g := range e.Guilds {
+func (h Ready) Serve(s *dgo.Session, ev *dgo.Ready) {
+	evErr := errors.NewEventError[GuildCreate](map[string]any{})
+
+	for _, g := range ev.Guilds {
 		err := h.db.GuildInsert(gdb.Guild[gconf.ConfigString]{ID: g.ID})

-		if err != nil && !errors.Is(err, gdb.ErrNoAffect) {
-			h.log.Error("Failed to add guild to database",
-				slog.String("id", g.ID),
-				slog.String("err", err.Error()),
-			)
+		if err != nil && !e.Is(err, gdb.ErrNoAffect) {
+			evErr.Wrapf("Failed to add guild to database", err).AddData("GuildID", g.ID).Log(h.log)
 		} else if err != nil {
 			h.log.Info("Guild already in database", slog.String("id", g.ID))
 		} else {
--- a/internals/discord/bot/events/messages.go
+++ b/internals/discord/bot/events/messages.go
@@ -1,15 +1,14 @@
 package events

 import (
-	e "errors"
-	"log/slog"
-	"slices"
-
 	"dislate/internals/discord/bot/errors"
 	"dislate/internals/discord/bot/gconf"
 	"dislate/internals/guilddb"
 	"dislate/internals/translator"
 	"dislate/internals/translator/lang"
+	e "errors"
+	"log/slog"
+	"slices"

 	dgo "github.com/bwmarrin/discordgo"
 )
@@ -33,6 +32,12 @@ func (h MessageCreate) Serve(s *dgo.Session, ev *dgo.MessageCreate) {
 }

 func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Message) {
+	evErr := errors.NewEventError[MessageCreate](map[string]any{
+		"GuildID":   msg.GuildID,
+		"ChannelID": msg.ChannelID,
+		"MessageID": msg.ID,
+	})
+
 	ch, err := h.db.Channel(msg.GuildID, msg.ChannelID)
 	if e.Is(err, guilddb.ErrNotFound) {
 		log.Debug("Channel is not in database, ignoring.",
@@ -42,12 +47,7 @@ func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Me
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", msg.GuildID),
-			slog.String("channel", msg.ChannelID),
-			slog.String("message", msg.ID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, msg)
+		evErr.Wrapf("Failed to get channel from database", err).Log(log).Reply(s, msg)
 		return
 	}

@@ -60,23 +60,13 @@ func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Me
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", msg.GuildID),
-			slog.String("channel", msg.ChannelID),
-			slog.String("message", msg.ID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, msg)
+		evErr.Wrapf("Failed to get channel group from database", err).Log(log).Reply(s, msg)
 		return
 	}

 	_, err = getMessage(h.db, msg, ch.Language)
 	if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", msg.GuildID),
-			slog.String("channel", msg.ChannelID),
-			slog.String("message", msg.ID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, msg)
+		evErr.Wrapf("Failed to get/add message to database", err).Log(log).Reply(s, msg)
 		return
 	}

@@ -89,11 +79,11 @@ func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Me

 			var channelID string
 			if err != nil {
-				errors.New("Failed to get information about channel",
-					slog.String("guild", msg.GuildID),
-					slog.String("channel", msg.ChannelID),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, msg)
+				evErr.Wrapf("Failed to get information about translated channel", err).
+					AddData("TranslatedChannel", c.ID).
+					Log(log).
+					Reply(s, msg)
+				return
 			} else if dch.IsThread() {
 				channelID = dch.ParentID
 			} else {
@@ -102,22 +92,21 @@ func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Me

 			uw, err := getUserWebhook(s, channelID, msg.Author)
 			if err != nil {
-				errors.NewErrUserWebhook(
-					slog.String("guild", msg.GuildID),
-					slog.String("channel", msg.ChannelID),
-					slog.Any("user", msg.Author),
-				).LogReply(log, s, msg)
+				evErr.Wrapf("Failed to get/set user webhook for translated channel", err).
+					AddData("TranslatedChannel", c.ID).
+					AddData("User", msg.Author.ID).
+					Log(log).
+					Reply(s, msg)
+				return
 			}

 			t, err := h.translator.Translate(ch.Language, c.Language, msg.Content)
 			if err != nil {
-				errors.New("Error while trying to translate message",
-					slog.String("guild", msg.GuildID),
-					slog.String("channel", msg.ChannelID),
-					slog.String("message", msg.ID),
-					slog.String("content", msg.Content),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, msg)
+				evErr.Wrapf("Error while trying to translate message", err).
+					AddData("content", msg.Content).
+					Log(log).
+					Reply(s, msg)
+				return
 			}

 			var tdm *dgo.Message
@@ -135,13 +124,13 @@ func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Me
 				})
 			}
 			if err != nil {
-				errors.NewErrUserWebhook(
-					slog.String("guild", msg.GuildID),
-					slog.String("channel", msg.ChannelID),
-					slog.String("message", msg.ID),
-					slog.String("content", msg.Content),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, msg)
+				evErr.Wrapf("Error while trying to execute user webhook", err).
+					AddData("content", msg.Content).
+					AddData("User", msg.Author.ID).
+					AddData("Webhook", uw.ID).
+					Log(log).
+					Reply(s, msg)
+				return
 			}

 			if tdm.GuildID == "" {
@@ -150,34 +139,39 @@ func (h MessageCreate) sendMessage(log *slog.Logger, s *dgo.Session, msg *dgo.Me

 			_, err = getTranslatedMessage(h.db, tdm, msg, c.Language)
 			if err != nil {
-				errors.NewErrDatabase(
-					slog.String("guild", msg.GuildID),
-					slog.String("channel", msg.ChannelID),
-					slog.String("message", msg.ID),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, msg)
+				evErr.Wrapf("Error while trying to get/set translated message", err).
+					AddData("TranslatedMessageID", tdm.ID).
+					Log(log).
+					Reply(s, msg)
+				return
 			}
 		}(c)

 	}
 }

-type MessageEdit struct {
+type MessageUpdate struct {
 	db         gconf.DB
 	translator translator.Translator
 }

-func NewMessageEdit(db gconf.DB, t translator.Translator) MessageEdit {
-	return MessageEdit{db, t}
+func NewMessageUpdate(db gconf.DB, t translator.Translator) MessageUpdate {
+	return MessageUpdate{db, t}
 }

-func (h MessageEdit) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {
+func (h MessageUpdate) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {
 	if ev.Message.Author.Bot || ev.Type != dgo.MessageTypeDefault {
 		return
 	}

 	log := gconf.GetLogger(ev.Message.GuildID, s, h.db)

+	evErr := errors.NewEventError[MessageUpdate](map[string]any{
+		"GuildID":   ev.Message.GuildID,
+		"ChannelID": ev.Message.ChannelID,
+		"MessageID": ev.Message.ID,
+	})
+
 	msg, err := h.db.Message(ev.Message.GuildID, ev.Message.ChannelID, ev.Message.ID)
 	if e.Is(err, guilddb.ErrNotFound) {
 		log.Debug("Message is not in database, ignoring.",
@@ -186,11 +180,7 @@ func (h MessageEdit) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", ev.Message.GuildID),
-			slog.String("channel", ev.Message.ChannelID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, ev.Message)
+		evErr.Wrapf("Failed to get message from database", err).Log(log).Reply(s, ev.Message)
 		return
 	}

@@ -202,11 +192,7 @@ func (h MessageEdit) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", ev.GuildID),
-			slog.String("channel", ev.ChannelID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, ev.Message)
+		evErr.Wrapf("Failed to get translated messages from database", err).Log(log).Reply(s, ev.Message)
 		return
 	}

@@ -217,11 +203,10 @@ func (h MessageEdit) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {
 		go func(m guilddb.Message) {
 			var channelID string
 			if dch, err := s.Channel(m.ChannelID); err != nil {
-				errors.New("Failed to get information about channel",
-					slog.String("guild", ev.Message.GuildID),
-					slog.String("channel", ev.Message.ChannelID),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, ev.Message)
+				evErr.Wrapf("Failed to get information about translated channel", err).
+					AddData("TranslatedChannel", m.ChannelID).
+					Log(log).
+					Reply(s, ev.Message)
 			} else if dch.IsThread() {
 				channelID = dch.ParentID
 			} else {
@@ -230,24 +215,20 @@ func (h MessageEdit) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {

 			uw, err := getUserWebhook(s, channelID, ev.Message.Author)
 			if err != nil {
-				errors.NewErrUserWebhook(
-					slog.String("guild", ev.Message.GuildID),
-					slog.String("channel", ev.Message.ChannelID),
-					slog.Any("user", ev.Message.Author),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, ev.Message)
+				evErr.Wrapf("Failed to get/set user webhook for translated channel", err).
+					AddData("TranslatedChannel", m.ChannelID).
+					AddData("User", ev.Message.Author.ID).
+					Log(log).
+					Reply(s, ev.Message)
 				return
 			}

 			t, err := h.translator.Translate(msg.Language, m.Language, ev.Message.Content)
 			if err != nil {
-				errors.New("Error while trying to translate message",
-					slog.String("guild", ev.Message.GuildID),
-					slog.String("channel", ev.Message.ChannelID),
-					slog.String("message", ev.Message.ID),
-					slog.String("content", ev.Message.Content),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, ev.Message)
+				evErr.Wrapf("Error while trying to translate message", err).
+					AddData("content", ev.Message.Content).
+					Log(log).
+					Reply(s, ev.Message)
 				return
 			}

@@ -255,13 +236,12 @@ func (h MessageEdit) Serve(s *dgo.Session, ev *dgo.MessageUpdate) {
 				Content: &t,
 			})
 			if err != nil {
-				errors.NewErrUserWebhook(
-					slog.String("guild", ev.Message.GuildID),
-					slog.String("channel", ev.Message.ChannelID),
-					slog.String("message", ev.Message.ID),
-					slog.String("content", ev.Message.Content),
-					slog.String("err", err.Error()),
-				).LogReply(log, s, ev.Message)
+				evErr.Wrapf("Error while trying to execute user webhook", err).
+					AddData("content", ev.Message.Content).
+					AddData("User", ev.Message.Author.ID).
+					AddData("Webhook", uw.ID).
+					Log(log).
+					Reply(s, ev.Message)
 				return
 			}
 		}(m)
@@ -283,6 +263,12 @@ func (h MessageDelete) Serve(s *dgo.Session, ev *dgo.MessageDelete) {
 	}
 	log := gconf.GetLogger(ev.Message.GuildID, s, h.db)

+	evErr := errors.NewEventError[MessageUpdate](map[string]any{
+		"GuildID":   ev.Message.GuildID,
+		"ChannelID": ev.Message.ChannelID,
+		"MessageID": ev.Message.ID,
+	})
+
 	msg, err := h.db.Message(ev.Message.GuildID, ev.Message.ChannelID, ev.Message.ID)
 	if e.Is(err, guilddb.ErrNotFound) {
 		log.Debug("Message is not in database, ignoring.",
@@ -291,11 +277,7 @@ func (h MessageDelete) Serve(s *dgo.Session, ev *dgo.MessageDelete) {
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", ev.Message.GuildID),
-			slog.String("channel", ev.Message.ChannelID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, ev.Message)
+		evErr.Wrapf("Failed to get message from database", err).Log(log).Reply(s, ev.Message)
 		return
 	}

@@ -319,11 +301,7 @@ func (h MessageDelete) Serve(s *dgo.Session, ev *dgo.MessageDelete) {
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("guild", ev.GuildID),
-			slog.String("channel", ev.ChannelID),
-			slog.String("err", err.Error()),
-		).LogReply(log, s, ev.Message)
+		evErr.Wrapf("Failed to get translated messages from database", err).Log(log).Reply(s, ev.Message)
 		return
 	}

@@ -351,11 +329,7 @@ func (h MessageDelete) Serve(s *dgo.Session, ev *dgo.MessageDelete) {
 	}

 	if err := h.db.MessageDelete(guilddb.NewMessage(msg.GuildID, msg.ChannelID, msg.ID, lang.EN)); err != nil {
-		errors.NewErrDatabase(
-			slog.String("channel", msg.ChannelID),
-			slog.String("message", msg.ID),
-			slog.String("err", err.Error()),
-		).LogSend(log, s, msg.ChannelID)
+		evErr.Wrapf("Failed to delete message from database", err).Log(log).Send(s, msg.ChannelID)
 	}
 }

--- a/internals/discord/bot/events/threads.go
+++ b/internals/discord/bot/events/threads.go
@@ -1,14 +1,14 @@
 package events

 import (
+	"dislate/internals/discord/bot/errors"
+	"dislate/internals/discord/bot/gconf"
+	"dislate/internals/translator"
 	e "errors"
 	"log/slog"
 	"sync"

-	"dislate/internals/discord/bot/errors"
-	"dislate/internals/discord/bot/gconf"
 	gdb "dislate/internals/guilddb"
-	"dislate/internals/translator"

 	dgo "github.com/bwmarrin/discordgo"
 )
@@ -26,6 +26,12 @@ func (h ThreadCreate) Serve(s *dgo.Session, ev *dgo.ThreadCreate) {
 	log := gconf.GetLogger(ev.GuildID, s, h.db)
 	log.Debug("Thread created!", slog.String("parent", ev.ParentID), slog.String("thread", ev.ID))

+	evErr := errors.NewEventError[ThreadCreate](map[string]any{
+		"ThreadID": ev.ID,
+		"ParentID": ev.ParentID,
+		"GuildID":  ev.GuildID,
+	})
+
 	// INFO: Threads have the same ID as the origin message of them
 	threadMsg, err := h.db.Message(ev.GuildID, ev.ParentID, ev.ID)
 	if e.Is(err, gdb.ErrNotFound) {
@@ -36,11 +42,7 @@ func (h ThreadCreate) Serve(s *dgo.Session, ev *dgo.ThreadCreate) {
 		)
 		return
 	} else if err != nil {
-		errors.New("Unable to get thread parent message from database",
-			slog.String("thread", ev.ID),
-			slog.String("parent", ev.ParentID),
-			slog.String("error", err.Error()),
-		).Log(log)
+		evErr.Wrap(e.New("Failed to get thread message"), err).Log(log).Send(s, ev.ID)
 		return
 	}

@@ -64,28 +66,21 @@ func (h ThreadCreate) Serve(s *dgo.Session, ev *dgo.ThreadCreate) {
 		)
 		return
 	} else if err != nil {
-		errors.NewErrDatabase(
-			slog.String("thread message", ev.ID),
-			slog.String("parent channel", ev.ParentID),
-			slog.String("error", err.Error()),
-		).LogSend(log, s, ev.ParentID)
+		evErr.Wrapf("Failed to get parent's translated messagas", err).
+			AddData("OriginMessageID", originMsg.ID).
+			AddData("OriginChannelID", originMsg.ChannelID).
+			Log(log).
+			Send(s, ev.ID)
 		return
 	}
 	msgs = append(msgs, originMsg)

 	dth, err := s.Channel(ev.ID)
 	if err != nil {
-		errors.New("Failed to get message thread object",
-			slog.String("thread", ev.ID),
-			slog.String("parent", ev.ParentID),
-			slog.String("error", err.Error()),
-		).LogSend(log, s, ev.ParentID)
+		evErr.Wrapf("Failed to get discord thread", err).Log(log).Send(s, ev.ID)
 		return
 	} else if !dth.IsThread() {
-		errors.New("Channel is not a thread for some reason",
-			slog.String("channel", ev.ID),
-			slog.String("parent", ev.ParentID),
-		).LogSend(log, s, ev.ID)
+		evErr.Wrapf("Channel is not a thread").Log(log).Send(s, ev.ID)
 		return
 	}

@@ -97,11 +92,7 @@ func (h ThreadCreate) Serve(s *dgo.Session, ev *dgo.ThreadCreate) {
 		)
 		return
 	} else if err != nil {
-		errors.New("Failed to add origin thread channel to database",
-			slog.String("thread", dth.ID),
-			slog.String("parent", dth.ParentID),
-			slog.String("err", err.Error()),
-		).LogSend(log, s, ev.ID)
+		evErr.Wrapf("Failed to add thread channel to database", err).Log(log).Send(s, ev.ID)
 		return
 	}

@@ -135,23 +126,17 @@ func (h ThreadCreate) Serve(s *dgo.Session, ev *dgo.ThreadCreate) {
 				},
 			)
 			if err != nil {
-				errors.New("Failed to create translated thread",
-					slog.String("origin thread", dth.ID),
-					slog.String("origin thread parent", dth.ParentID),
-					slog.String("error", err.Error()),
-				).LogSend(log, s, ev.ID)
+				evErr.Wrapf("Failed to create translated thread", err).Log(log).Send(s, ev.ID)
 				return
 			}

 			if err := h.db.ChannelInsert(gdb.NewChannel(dtth.GuildID, dtth.ID, m.Language)); err != nil &&
 				!e.Is(err, gdb.ErrNoAffect) {
-				errors.New("Failed to add thread channel to database",
-					slog.String("thread", dth.ID),
-					slog.String("parent", dth.ParentID),
-					slog.String("origin thread", dth.ID),
-					slog.String("origin thread parent", dth.ParentID),
-					slog.String("err", err.Error()),
-				).LogSend(log, s, dtth.ParentID)
+				evErr.Wrapf("Failed to add translated thread to database", err).
+					AddData("TranslatedThreadID", dtth.ID).
+					AddData("TranslatedParentID", dtth.ParentID).
+					Log(log).
+					Send(s, ev.ID)
 				return
 			}
 		}(m)
@@ -160,22 +145,16 @@ func (h ThreadCreate) Serve(s *dgo.Session, ev *dgo.ThreadCreate) {
 	wg.Wait()

 	if err := h.db.ChannelGroupInsert(threadGroup); err != nil {
-		errors.New("Failed to insert group of threads in database",
-			slog.String("origin thread", dth.ID),
-			slog.String("origin thread parent", dth.ParentID),
-			slog.Any("thread group", threadGroup),
-			slog.String("error", err.Error()),
-		).LogSend(log, s, ev.ID)
+		evErr.Wrapf("Failed to add group of threads to database", err).
+			AddData("ThreadGroup", threadGroup).
+			Log(log).
+			Send(s, ev.ID)
 		return
 	}

 	thMsgs, err := s.ChannelMessages(th.ID, 10, "", "", "")
 	if err != nil {
-		errors.New("Failed to get thread messages",
-			slog.String("thread", dth.ID),
-			slog.String("parent", dth.ParentID),
-			slog.String("err", err.Error()),
-		).LogSend(log, s, ev.ID)
+		evErr.Wrapf("Failed to get thread messages", err).Log(log).Send(s, ev.ID)
 		return
 	}