The documentation for Microsoft Graph webhooks is not clear on the durability of events. If a client creates a subscription and then subsequently goes down (say, for maintenance), what happens to events that occur while the client is unavailable? Are they queued and retried by the Microsoft Graph until the client comes back online, or are they lost? If they are queued, for how long?
Graph Webhook will try to send the events a number of times within 4 hours window. If the client does not come back online after 4 hours, then these events will be deleted.
Related
I have a notification-only bot, and I would like to send a welcome message to users only when the bot is added to a personal conversation.
I listen to 'conversationUpdate' events as stated here, though I keep receiving the same event multiple times one after the other for the same user, all events identical (except the event ID and timestamp).
I respond to the event with HTTP status 200 (I handle them via REST).
Does anyone have an idea why I would receive the same events multiple times and how to avoid it? Is it some kind of retry due to an unexpected response on my end?
It even says here: "For personal scoped bots, your bot will only ever receive the conversationUpdate event a single time, even if the bot is removed and re-added."
I have set up a webhook/subscription mechanism to receive push notifications of Teams calls. I am then passing those ID values to the CallRecord API endpoint to retrieve call data. This is then being streamed using Stream Analytics to a database.
Going through the data, there are lots of duplicate calls with the same call ID being pushed at various different times several hours apart in some cases.
I have noticed that the CallRecord API endpoint as of yesterday has been moved out of beta/preview. Is this a bug?
Short version:
In my case what removed the duplicates was responding with status 200 ok at the end of my notificationUrl handler.
Long version:
I had the (same?) problem of receiving the same change notification for the same callRecord id and the same subscription every 5 minutes.
I was using a http triggered flow for the notificationUrl but only consumed the data and didn't respond.
Then I saw the Microsoft video introducing deltas and change notifications again and noticed that the azure function in their example responds with okay in the end.
After I added a http 200 response in my Flow, the duplicate change notifications stopped after the next run.
I do use the PAHO C client library in my application. I do subscribe topics with MQTTAsync_subscribe() and QoS set to 1. From what I understand is that 1 means, that a message is send to the client at least one time.
I disconnect the client that subscribed the topic and the client that published the topic is still sending messages to the Mosquitto broker. If I start the subscriber lets say hours later, I get all the buffered messages beginning from the last one when the subscriber was shut down. So far so good! But the problem is, that the messages arrive in the same interval as the publisher sends new messages. By doing so, you will never get the latest message queued up by the publisher.
What I expect is that the Mosquitto broker tries to send all pending messages one after the other to the client instead of sending one old message when a new one is published.
Maybe someone can help me to understand why this happens or maybe how to overcome this situation?
Queued messages should all be batch delivered when the client reconnects.
They are not queued up and delivered with the same time offset, mosquitto wouldn't even keep time of arrival to be able to do time offset delayed delivery (Time of arrival is kept for MQTT v5 messages because they can now have TTL value, but this is only used to remove expired messages from the queue, not to delay late delivery).
we are using Microsoft Graph notification to monitor certain resource changes such as group creation/deletion, etc.
In the MS doc it says "Send a 202 - Accepted status code in your response to Microsoft Graph. If Microsoft Graph doesn't receive a 2xx class code, it will retry the notification a number of times."
We'd want to have a better understanding on how this works, such as what are the timeout values (how long does Graph wait before it re-sends the notification?), and how many times it retries (is it a guaranteed delivery?), etc. Can anybody help shed some light on this?
I am facing an issue with the presence status, following the documentation and XMPPframework example code. I have written a chat application.
Problem : When the user 1 & 2 are online I get the status successfully and they can chat with each other. However when the user 2 goes physically offline via (Wifi OFF / 3G Off) User 1 is not getting the offline status from XMPP and hence what ever messages are sent from that instant of time are lost when the user 2 comes online.
It seems since the user 2 is not notified or stored as offline in XMPP and hence its not storing the offline messages to push back to user 2 when it comes online.
I have tried to resolve this by explicitly writing a [goOffline] call to XMPP, however the call is shown in 'SEND log' for 'user 2' but not received in 'RECV log' in user 1 from XMPP, due to which the message are lost in between.
Also tried with other sources replies.
Set status for presence available and send XMPP
priority changed with values non-negative
XMPPArchiving work but this is not what I wanted.
Server side Mod_zero push enables but get only first message push notification sometimes.
Setting limit on ejabberd.cfg file for users and offline message limit.
request for offline message pull.
Can anyone help me with this?
This is very typical situation where client losses network but server can't detect that it is offline.
To detect status of each client, server need to send PING packets to every client and wait for response.
If client responds then fine otherwise server will mark that client as offline and every other online client will be informed automatically.
Here is PING Module implementation for ejabberd XMPP Server (hope you are using ejabberd server):
mod_ping:
send_pings: true
ping_interval: 10
timeout_action: kill
ping_ack_timeout: 10
This has to be written in ejabberd.yml configuration file.
At client side also we need to enable ping module to respond to server pings as:
private var xmppPing: XMPPPing?
xmppPing = XMPPPing()
xmppPing!.activate(xmppStream!)
This code has to be written while we setupStream() for iOS.
For detailed info, please go through mod_ping documentations.
Sounds like your problem is at server level. The server thinks that the user is online so it sends the message but nobody gets it. This does not really have a simple solution.
1.
The best solution would be delivery receipts. Where basically when the message is sent to your client, your client returns a confirmation of delivery receipt. If the server does not get that receipt it would resend the message every n time. Depending on your XMPP server you might find a already made solution, of not you would have to roll out your own.
2.
A possible hack would be to have your server always store and deliver last 10 messages and then at client side you discard repeated... This also depends on your server implementation. XMPP MUC and PubSub have resources along these lines.
For a long term scalable solution, you'll need to deal with this both at server and client level.