Log each change of the WhatsApp connection

[onechat] / whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 75de73f96c57b25fb717bde9189103e5518b3937..2c1b6cb9aaa70e327fd4a342d282fb97ecd4a247 100644 (file)
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -405,7 +405,7 @@ func (w *WhatsApp) connect(ctx context.Context) {
 
        err := client.ConnectContext(ctx)
        if err != nil {
-               w.logger.Printf("connect: %s", w.redact(err.Error()))
+               w.logger.Printf("WhatsApp messages do not come, because the connection failed, and it is tried again only at a restart of the daemon: %s", w.redact(err.Error()))
        }
 }
 
@@ -435,6 +435,7 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
                return nil
        }
 
+       w.logger.Print("WhatsApp messages stop, because the phone logged out this device (run /whatsapp pair PHONE to link it again)")
        err := w.inbox.deliver(ctx, l, w.link(), true)
        if err != nil {
                return err
@@ -442,12 +443,12 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error {
 
        err = w.removeSession()
        if err != nil {
-               w.logger.Printf("delete the session after the logout: %v", err)
+               w.logger.Printf("the session of the logged out device stays on the disk, because its delete failed: %v", err)
        }
 
        err = l.note("WhatsApp was unlinked from the phone.")
        if err != nil {
-               w.logger.Printf("note the logout: %v", err)
+               w.logger.Printf("the chat has no note of the logout, because its write failed: %v", err)
        }
 
        w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.")
@@ -490,9 +491,10 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
                return nil
        }
 
+       w.logger.Print("WhatsApp messages stop, because the user unlinked WhatsApp")
        err = l.note("WhatsApp is unlinked.")
        if err != nil {
-               w.logger.Printf("note the unlink: %v", err)
+               w.logger.Printf("the chat has no note of the unlink, because its write failed: %v", err)
        }
 
        if client == nil || logoutErr != nil {
@@ -514,6 +516,7 @@ func (w *WhatsApp) removeSession() error {
        w.linked = false
        w.own = nil
        w.connected = false
+       w.disconnectedAt = time.Time{}
        if w.timer != nil {
                w.timer.Stop()
        }
@@ -628,10 +631,11 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string,
                case item.Event == whatsmeow.QRChannelSuccess.Event:
                        linked = true
                        w.linkedBy(client)
+                       w.logger.Print("WhatsApp is linked")
 
                        err = l.note("WhatsApp is linked.")
                        if err != nil {
-                               w.logger.Printf("note the link: %v", err)
+                               w.logger.Printf("the chat has no note of the link, because its write failed: %v", err)
                        }
 
                        answer("WhatsApp is linked to +" + phone + ".")
@@ -694,6 +698,11 @@ func (w *WhatsApp) linkedBy(client WhatsAppClient) {
 // the library tries again. After noticeDelay of a disconnection, all clients
 // get one notice, and they get one more when the connection comes back. A
 // disconnection that the library does not try again gives a notice at once.
+//
+// The log of the daemon gets one line for each change of the connection of the
+// linked device: connected, a failed first connection, a lost connection, and
+// connected again with the length of the outage. The retries of the library
+// between them log nothing.
 func (w *WhatsApp) handle(event any) bool {
        switch event := event.(type) {
        case *events.Message:
@@ -714,12 +723,20 @@ func (w *WhatsApp) handle(event any) bool {
                w.inbox.startCatchup()
        }
 
-       var notice string
+       var notice, line string
        w.mutex.Lock()
        switch event := event.(type) {
        case *events.PairSuccess:
                w.own = whatsappOwnIDs(event.ID.User, event.LID.User)
        case *events.Connected:
+               switch {
+               case !w.linked || w.connected:
+               case w.disconnectedAt.IsZero():
+                       line = "WhatsApp is connected, and new messages come in"
+               default:
+                       line = "WhatsApp is connected again, after " + durationText(w.clock().Sub(w.disconnectedAt))
+               }
+
                w.connected = true
                w.connectedAt = w.clock()
                if w.timer != nil {
@@ -732,6 +749,11 @@ func (w *WhatsApp) handle(event any) bool {
                }
        case *events.Disconnected:
                if w.linked && (w.connected || w.disconnectedAt.IsZero()) {
+                       line = "new WhatsApp messages wait, because the connection is lost (the next try is automatic)"
+                       if !w.connected {
+                               line = "new WhatsApp messages wait, because the first connection failed (the next try is automatic)"
+                       }
+
                        w.disconnectedAt = w.clock()
                        w.disconnections++
                        disconnections := w.disconnections
@@ -751,10 +773,20 @@ func (w *WhatsApp) handle(event any) bool {
                        w.connected = false
                        w.noticed = true
                        notice = "WhatsApp is disconnected and does not connect again by itself: " + event.PermanentDisconnectDescription() + ". Restart the daemon to try again."
+                       line = "WhatsApp messages do not come, because the connection is lost and it is tried again only at a restart of the daemon: " + whatsappRedact(w.own, event.PermanentDisconnectDescription())
                }
        }
+
+       if w.closed {
+               line = ""
+       }
+
        w.mutex.Unlock()
 
+       if line != "" {
+               w.logger.Print(line)
+       }
+
        if notice != "" {
                w.broadcast(notice)
        }