diff --git a/output/xmpp/main.go b/output/xmpp/main.go
index ac4eadd..903015c 100644
--- a/output/xmpp/main.go
+++ b/output/xmpp/main.go
@@ -84,12 +84,12 @@ func Init(configInterface interface{}, db *database.DB, bot *bot.Bot) output.Out
 			}
 		}
 		logger.Info("join muc after connect")
+		out.client = c
 	})
 	go func() {
 		cm.Run()
 		log.Panic("closed connection")
 	}()
-	out.client = client
 
 	logger.WithField("jid", config.JID).Info("startup")
 	return out
@@ -106,11 +106,10 @@ func (out *Output) Close() {
 			logger.Error("xmpp could generate jid to leave ", jid, " error:", err)
 		}
 		toJID.Resource = nickname
-		err = out.client.Send(stanza.Presence{Attrs: stanza.Attrs{
+		if err = out.client.Send(stanza.Presence{Attrs: stanza.Attrs{
 			To:   toJID.Full(),
 			Type: stanza.PresenceTypeUnavailable,
-		}})
-		if err != nil {
+		}}); err != nil {
 			logger.Error("xmpp could not leave ", toJID.Full(), " error:", err)
 		}
 	}
diff --git a/output/xmpp/recv.go b/output/xmpp/recv.go
index ab00667..6f97b98 100644
--- a/output/xmpp/recv.go
+++ b/output/xmpp/recv.go
@@ -3,31 +3,32 @@ package xmpp
 import (
 	"time"
 
-	"github.com/bdlm/log"
 	"gosrc.io/xmpp"
+	"gosrc.io/xmpp/stanza"
 )
 
-func (out *Output) recvMessage(s xmpp.Sender, p xmpp.Packet) {
+func (out *Output) recvMessage(s xmpp.Sender, p stanza.Packet) {
 	before := time.Now()
 
-	msg, ok := p.(xmpp.Message)
+	msg, ok := p.(stanza.Message)
 	if !ok {
-		log.Errorf("blame gosrc.io/xmpp for routing: %s", p)
+		logger.Errorf("blame gosrc.io/xmpp for routing: %s", p)
 		return
 	}
-	log.WithFields(map[string]interface{}{
+	logger.WithFields(map[string]interface{}{
 		"sender":  msg.From,
 		"request": msg.Body,
 	}).Debug("handling bot message")
+
 	from, err := xmpp.NewJid(msg.From)
 	if err != nil {
-		log.Errorf("blame gosrc.io/xmpp for jid encoding: %s", msg.From)
+		logger.Errorf("blame gosrc.io/xmpp for jid encoding: %s", msg.From)
 		return
 	}
 
 	fromBare := from.Bare()
 	fromLogmania := ""
-	if msg.Type == xmpp.MessageTypeGroupchat {
+	if msg.Type == stanza.MessageTypeGroupchat {
 		fromLogmania = protoGroup + ":" + fromBare
 	} else {
 		fromLogmania = proto + ":" + fromBare
@@ -37,13 +38,18 @@ func (out *Output) recvMessage(s xmpp.Sender, p xmpp.Packet) {
 	if answer == "" {
 		return
 	}
-	reply := xmpp.Message{Attrs: xmpp.Attrs{To: fromBare, Type: msg.Type}, Body: answer}
-	s.Send(reply)
+	if err := s.Send(stanza.Message{Attrs: stanza.Attrs{To: fromBare, Type: msg.Type}, Body: answer}); err != nil {
+		logger.WithFields(map[string]interface{}{
+			"sender":  fromLogmania,
+			"request": msg.Body,
+			"answer":  answer,
+		}).Errorf("unable to send bot answer: %s", err)
+	}
 
 	after := time.Now()
 	delta := after.Sub(before)
 
-	log.WithFields(map[string]interface{}{
+	logger.WithFields(map[string]interface{}{
 		"sender":  fromLogmania,
 		"request": msg.Body,
 		"answer":  answer,
@@ -51,42 +57,48 @@ func (out *Output) recvMessage(s xmpp.Sender, p xmpp.Packet) {
 	}).Debug("handled xmpp bot message")
 }
 
-func (out *Output) recvPresence(s xmpp.Sender, p xmpp.Packet) {
-	pres, ok := p.(xmpp.Presence)
+func (out *Output) recvPresence(s xmpp.Sender, p stanza.Packet) {
+	pres, ok := p.(stanza.Presence)
 	if !ok {
-		log.Errorf("blame gosrc.io/xmpp for routing: %s", p)
+		logger.Errorf("blame gosrc.io/xmpp for routing: %s", p)
 		return
 	}
 	from, err := xmpp.NewJid(pres.From)
 	if err != nil {
-		log.Errorf("blame gosrc.io/xmpp for jid encoding: %s", pres.From)
+		logger.Errorf("blame gosrc.io/xmpp for jid encoding: %s", pres.From)
 		return
 	}
 	fromBare := from.Bare()
 	logPres := logger.WithField("from", from)
 
 	switch pres.Type {
-	case xmpp.PresenceTypeSubscribe:
+	case stanza.PresenceTypeSubscribe:
 		logPres.Debugf("recv presence subscribe")
-		s.Send(xmpp.Presence{Attrs: xmpp.Attrs{
-			Type: xmpp.PresenceTypeSubscribed,
+		if err := s.Send(stanza.Presence{Attrs: stanza.Attrs{
+			Type: stanza.PresenceTypeSubscribed,
 			To:   fromBare,
 			Id:   pres.Id,
-		}})
+		}}); err != nil {
+			logPres.WithField("user", pres.From).Errorf("answer of subscribe not send: %s", err)
+			return
+		}
 		logPres.Debugf("accept new subscribe")
 
-		s.Send(xmpp.Presence{Attrs: xmpp.Attrs{
-			Type: xmpp.PresenceTypeSubscribe,
+		if err := s.Send(stanza.Presence{Attrs: stanza.Attrs{
+			Type: stanza.PresenceTypeSubscribe,
 			To:   fromBare,
-		}})
+		}}); err != nil {
+			logPres.WithField("user", pres.From).Errorf("request of subscribe not send: %s", err)
+			return
+		}
 		logPres.Info("request also subscribe")
-	case xmpp.PresenceTypeSubscribed:
+	case stanza.PresenceTypeSubscribed:
 		logPres.Info("recv presence accepted subscribe")
-	case xmpp.PresenceTypeUnsubscribe:
+	case stanza.PresenceTypeUnsubscribe:
 		logPres.Info("recv presence remove subscribe")
-	case xmpp.PresenceTypeUnsubscribed:
+	case stanza.PresenceTypeUnsubscribed:
 		logPres.Info("recv presence removed subscribe")
-	case xmpp.PresenceTypeUnavailable:
+	case stanza.PresenceTypeUnavailable:
 		logPres.Debug("recv presence unavailable")
 	case "":
 		logPres.Debug("recv empty presence, maybe from joining muc")
diff --git a/output/xmpp/send.go b/output/xmpp/send.go
index 53ecb2d..9c15a8b 100644
--- a/output/xmpp/send.go
+++ b/output/xmpp/send.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/bdlm/log"
 	"gosrc.io/xmpp"
+	"gosrc.io/xmpp/stanza"
 
 	"dev.sum7.eu/genofire/logmania/database"
 )
@@ -12,19 +13,18 @@ import (
 func (out *Output) Join(to string) {
 	toJID, err := xmpp.NewJid(to)
 	if err != nil {
-		logger.Error("xmpp could not generate jid to join ", to, " error:", err)
+		logger.Errorf("jid not generate to join muc %s : %s", to, err)
 		return
 	}
 	toJID.Resource = nickname
 
-	err = out.client.Send(xmpp.Presence{Attrs: xmpp.Attrs{To: toJID.Full()},
-		Extensions: []xmpp.PresExtension{
-			xmpp.MucPresence{
-				History: xmpp.History{MaxStanzas: xmpp.NewNullableInt(0)},
+	if err = out.client.Send(stanza.Presence{Attrs: stanza.Attrs{To: toJID.Full()},
+		Extensions: []stanza.PresExtension{
+			stanza.MucPresence{
+				History: stanza.History{MaxStanzas: stanza.NewNullableInt(0)},
 			}},
-	})
-	if err != nil {
-		logger.Error("xmpp could not join ", toJID.Full(), " error:", err)
+	}); err != nil {
+		logger.Errorf("muc not join %s : %s", toJID.Full(), err)
 	} else {
 		out.channels[to] = true
 	}
@@ -39,26 +39,36 @@ func (out *Output) Send(e *log.Entry, to *database.Notify) bool {
 	html = strings.TrimRight(to.RunReplace(html), "\n")
 	text = strings.TrimRight(to.RunReplace(text), "\n")
 
-	msg := xmpp.Message{
-		Attrs: xmpp.Attrs{
+	msg := stanza.Message{
+		Attrs: stanza.Attrs{
 			To: to.To,
 		},
 		Body: text,
-		Extensions: []xmpp.MsgExtension{
-			xmpp.HTML{Body: xmpp.HTMLBody{InnerXML: html}},
+		Extensions: []stanza.MsgExtension{
+			stanza.HTML{Body: stanza.HTMLBody{InnerXML: html}},
 		},
 	}
 	if to.Protocol == protoGroup {
 		if _, ok := out.channels[to.To]; ok {
 			out.Join(to.To)
 		}
-		msg.Type = xmpp.MessageTypeGroupchat
-		out.client.Send(msg)
+		msg.Type = stanza.MessageTypeGroupchat
+		if err := out.client.Send(msg); err != nil {
+			logger.WithFields(map[string]interface{}{
+				"muc":  to.To,
+				"text": text,
+			}).Errorf("log message not forwarded: %s", err)
+		}
 		return true
 	}
 	if to.Protocol == proto {
-		msg.Type = xmpp.MessageTypeChat
-		out.client.Send(msg)
+		msg.Type = stanza.MessageTypeChat
+		if err := out.client.Send(msg); err != nil {
+			logger.WithFields(map[string]interface{}{
+				"user": to.To,
+				"text": text,
+			}).Errorf("log message not forwarded: %s", err)
+		}
 		return true
 	}
 	return false