Le modifiche non vengono salvate nella tabella user_actions

Pensavo che ogni volta che un utente modifica un post di qualcun altro, questa azione venisse registrata nella tabella user_actions, ma mi sono appena reso conto che ciò accade solo sporadicamente (solo per alcuni utenti, in alcuni momenti).

È questo il comportamento previsto o c’è un’altra condizione che non sto considerando?

È difficile fornire una procedura passo passo per riprodurre questo problema, ma ecco come l’ho rilevato:

  1. Trova un post con una notifica di modifica:
  2. Esegui una query su user_actions per l’acting_user_id dato (l’editor), l’user_id dato (l’utente modificato) e il topic_id dato. Nel mio caso:
select * from user_actions ua 
where ua.acting_user_id = 229 
and ua.user_id = 259 
and ua.target_topic_id = 1907;

Questo è quanto ottengo:

  • Il tipo di azione 2 significa che l’utente modificato ha ricevuto un LIKE dall’editor.
  • Il tipo di azione 6 significa che l’editor ha risposto all’utente modificato.
  id   | action_type | user_id | target_topic_id | target_post_id | target_user_id | acting_user_id |         created_at         |         updated_at
-------+-------------+---------+-----------------+----------------+----------------+----------------+----------------------------+----------------------------
 78476 |           2 |     259 |            1907 |          17893 |                |            229 | 2020-03-20 03:39:12.255619 | 2020-03-20 03:39:12.395574
 78478 |           6 |     259 |            1907 |          17900 |                |            229 | 2020-03-20 03:44:04.847102 | 2020-03-20 03:44:04.847102

Posso confermare entrambe queste azioni nell’interfaccia utente, ma mi aspetterei anche di trovare un action_type 11 che indichi la MODIFICA.

Oltre a vedere la modifica nell’interfaccia utente, posso anche confermarne l’esistenza nella tabella post_revisions eseguendo una query utilizzando il target_post_id:

select id, user_id, post_id, number, created_at, updated_at from post_revisions pr where post_id = 17893;

  id  | user_id | post_id | number |         created_at         |         updated_at         |
------+---------+---------+--------+----------------------------+----------------------------+--------
 8927 |     229 |   17893 |      2 | 2020-03-20 03:40:06.644576 | 2020-03-20 03:43:32.769535 |

Allora, perché questa azione non appare in user_actions?

Le modifiche non sono destinate a essere archiviate lì; sono archiviate in post_revisions.

Giusto, non la modifica. Intendo l’evento user_action EDIT:

Il fatto è che viene attivato il 90% delle volte. Non capisco perché non funzioni nel restante 10%.

Ho appena realizzato che o non comprendo appieno i casi in cui viene creata una notifica di modifica, oppure questo è un problema molto più diffuso di quanto pensassi.

Ipotesi principali

Se l’Utente A modifica quanto scritto dall’Utente B, accadono diverse cose:

  • Viene aggiunta una nuova riga alla tabella post_revisions.
  • Viene aggiunta una nuova riga alla tabella user_actions con action_type = 11.
  • Accedendo a /u/userB/notifications/edits, l’Utente B potrà vedere che l’Utente A ha effettuato una nuova modifica (questo dipende da user_actions).
  • Cliccando sull’icona della matita nel suo post, l’Utente B potrà vedere la modifica effettiva eseguita dall’Utente A (questo dipende da post_revisions).

Test

Se le ipotesi sopra sono corrette, questa query dovrebbe mostrare tutte le righe nella tabella post_revisions per i post creati dall’Utente B (in questo caso, id 259) che sono stati modificati da qualsiasi utente (diverso da se stesso o dall’utente di sistema), assieme alle righe corrispondenti in user_actions per action_type = 11.

with my_user_posts as (
  select
    p.id,
    p.user_id
  from
    posts p
  where
    p.user_id = 259 -- scegli un id utente
)
select
  up.user_id as my_user_id,
  ua.user_id as target_user_id,
  pr.post_id,
  ua.target_post_id,
  pr.user_id as editor_user_id,
  ua.acting_user_id,
  ua.action_type,
  pr.created_at as edit_created_at,
  ua.created_at as action_created_at
from
  post_revisions pr
  inner join my_user_posts up on up.id = pr.post_id
  and up.user_id != pr.user_id -- nessuna modifica a se stessi
  and pr.user_id != -1 -- nessuna modifica di sistema
  left join user_actions ua on ua.target_post_id = pr.post_id
  and ua.action_type = 11 -- solo azioni di MODIFICA
order by
  pr.post_id,
  pr.created_at;

Output atteso

Ogni riga contiene sia i dati di post_revisions che quelli di user_actions.

Output effettivo

Alcune righe di post_revisions non hanno dati corrispondenti in user_actions. Di conseguenza, l’utente può vedere le revisioni cliccando sulla matina in ogni post, ma non è stato notificato di aver ricevuto diverse modifiche.

Cose che ho provato

  • Aggiungere una modifica aggiuntiva a un vecchio post senza dati user_action. Risultato: i dati user_action non sono apparsi nemmeno in questo caso.
  • Creare un utente finto, copiare il contenuto pre-modifica di un post senza dati user_action, creare un post con esso e applicare la stessa modifica eseguita con un utente diverso. Risultato: i dati user_action sono apparsi correttamente.
  • Ripetere le procedure sopra quando l’utente è attivo o offline. Risultato: nessuna variazione.
  • Ripetere le procedure sopra modificando il periodo di grazia per le modifiche. Risultato: nessuna variazione.

Conclusioni

  • Il problema non sembra essere:

    • specifico dell’utente. Si verifica praticamente con ogni utente.
    • specifico della connessione. Il fatto che l’utente sia attivo o offline non cambia l’output.
    • specifico del tempo. Modificare il periodo di grazia per le modifiche non ha avuto alcun effetto.
  • Il problema sembra essere

    • specifico dell’azione. Non ho riscontrato problemi con la notifica di altre azioni (LIKE, WAS_LIKED, RESPONSE, REPLY, MENTION o QUOTE). L’unico problema riguarda le azioni di MODIFICA.

    • specifico del post. Non si verifica con ogni post, solo con alcuni specifici (a quanto pare in modo casuale)

  • Una possibilità è che qualcosa accada durante la creazione di post specifici impedendo il salvataggio delle azioni user_actions di tipo EDIT, ma non ho idea di cosa potrebbe essere.

  • È anche possibile che ciò avvenga per progettazione e che esistano condizioni specifiche in cui gli utenti non vengono notificati delle modifiche, ma non ho trovato tale informazione documentata da nessuna parte.

Prossimi passi

  • Se conosci un motivo per cui le notifiche di modifica potrebbero non essere attivate ogni volta che viene effettuata una modifica, fammelo sapere.
  • Se hai la tua istanza di Discourse, potresti eseguire la query SQL sopra su alcuni dei tuoi id utente per verificare se anche tu vedi dati mancanti in user_actions e farmi sapere?

Voglio solo essere assolutamente certo che tu abbia chiaro il concetto dei periodi di grazia per le modifiche, che continuano a valere anche se a modificare il post è un utente diverso.

(Sì, se l’utente A modifica il post dell’utente B, viene sempre creata una revisione forzata dell’edit, ma questo non significa che se l’utente A modifica il post dell’utente B 6 volte in 60 secondi, vengano create 6 revisioni e 6 notifiche. Come puoi vedere nello screenshot sopra, verrà creata una sola revisione e una sola notifica.)

Ognuna di queste modifiche è stata effettuata a più di 5 minuti di distanza dall’altra?

Grazie per il commento, Jeff. Posso confermare che sì, queste modifiche sono state effettuate a più di 5 minuti di distanza. Ma anche se non lo fossero, finché viene creata una singola post_revision, non dovrebbe esserci SEMPRE un’azione utente EDIT associata?

A margine, ho anche provato a impostare il periodo di grazia per la modifica a 0 e, in tal caso, vengono create due post_revision identiche per ogni modifica. Non so se questo sia previsto dal design o se si tratti di un bug non correlato.

Sto solo verificando, è bene averne conferma.

Qualcuno potrebbe eseguire la query sopra sul proprio sito Discourse per verificare se ottiene anche revisioni dei post senza azioni utente corrispondenti di tipo 11?

Analizzando il nostro codice, credo che il tipo user_action 11 venga assegnato solo se modificate un post di qualcun altro o se in qualche modo si attiva una notifica relativa alla modifica.

Grazie, Sam. Era quello che mi aspettavo, ma non è ciò che ho riscontrato (almeno sul mio sito). Come puoi vedere dai risultati della mia query, in alcuni casi, l’utente A modifica un post di utente B (il che aggiunge una riga in post_revisions), ma non esiste una riga corrispondente in user_actions (con action_type 11). Questo è ciò che non capisco.

Hai una riproduzibile del problema, è un evento isolato?

È successo in modo continuo e sporadico da quando ho avviato il mio sito. Non sono riuscito a individuare il pattern, come ho menzionato sopra.

Se c’è un modo per fornirti un dump dei dati o se hai bisogno di altre informazioni, sono felice di aiutarti.

Solo per essere sicuro, il bug effettivo che stai segnalando qui è:

In alcune condizioni, l’utente A modifica un post dell’utente B e l’utente B non riceve una notifica?

Esatto. La notifica non appare qui né nella casella dell’utente (poiché entrambe dipendono da user_actions):

Tuttavia, appare nell’angolo in alto a destra del post (poiché dipende da post_revisions):

Ho scritto una query per testare questo. Se la eseguite sul vostro sito (con diversi ID utente), dovreste vedere anche voi delle lacune.

Si tratta di un’istanza ospitata da noi o di un’istanza self-hosted?

La nostra notifica viene attivata qui:

La condizione è piuttosto rigida:

La notifica viene creata qui:

Ciò che potrebbe interrompere questo processo è:

  1. Sidekiq bloccato con code di lavori in sospeso o in pausa

  2. Una condizione estremamente rara di interruzione del lavoro a metà della fase di notifica

Posso fornirti un esempio specifico in un’istanza ospitata da te.

Questo post (ID 1067), creato dall’utente 3 il 2019-08-03 alle 19:22 UTC, è stato modificato da me (utente 2) pochi minuti dopo la sua creazione.

Tuttavia, non è stato creato alcun user_action di tipo 11 (a differenza delle altre 2 modifiche che quell’utente ha ricevuto lo stesso giorno sui post 1001 e 1003).

Puoi vederlo più chiaramente eseguendo questa query:

with my_user_posts as (
  select
    p.id,
    p.user_id
  from
    posts p
  where
    p.user_id = 3 -- scegli un ID utente
)
select
  up.user_id as my_user_id,
  ua.user_id as target_user_id,
  pr.post_id,
  ua.target_post_id,
  pr.user_id as editor_user_id,
  ua.acting_user_id,
  ua.action_type,
  pr.created_at as edit_created_at,
  ua.created_at as action_created_at
from
  post_revisions pr
  inner join my_user_posts up on up.id = pr.post_id
  and up.user_id != pr.user_id -- nessuna modifica a se stessi
  and pr.user_id != -1 -- nessuna modifica di sistema
  left join user_actions ua on ua.target_post_id = pr.post_id
  and ua.action_type = 11 -- solo azioni di MODIFICA  
WHERE
  pr.created_at between '2019-08-03' and '2019-08-04'
order by
  pr.post_id,
  pr.created_at

Ho eseguito alcune analisi e, a seconda della data, tra il 7% e il 25% delle post_revisions non personali non hanno un user_action corrispondente.

Dopotutto, potrebbe esserci un bug qui @Nacho_Caballero… attendete. Grazie per aver insistito su questo.

Avevamo questo bug:

E ho migliorato l’implementazione con questa funzionalità:

C’era un caso limite in cui, quando un utente metteva “mi piace” a un post di un altro utente e successivamente lo modificava, non ricevevamo una notifica sulla modifica.

Inoltre, ho aggiunto un meccanismo di sicurezza che garantisce una notifica incondizionata una volta al giorno, anche se si tratta dello stesso autore che modifica. (Le notifiche per modifiche ripetute dallo stesso autore vengono soppresse per 1 giorno). Al momento, questa impostazione non è configurabile.

Ottimo. Ha molto senso. Grazie mille per la correzione!