How to postponed event trigger/receive

SUM: how to postponed event fire or event receive in azure event grid?

I designing system which needs to react to low frequency OBJECT states (create, start, check-long-time-in-started-state, end). It looks like candidate to event processing. I would like to implement it with azure functions ...
Problem is that I need to react to OBJECT which are 10 minutes (configurable) in STARTED state. To react 10 minutes AFTER a event happend. How to delay event fire? How to schedule event fire? How to wait for event ?
Iam looking for solution which will not consume my paid resources (function processing time).
Any idea how to solve this posponing ? Thank you.

Function 1:

• time triggered (polling)
• check condition
  • could create OBJECT-created event

Function 2:

• http triggered
• user start OBJECT from UI
  • create OBJECT-started event but fire it 10 minutes from NOW ? (to sleep/timer in function code would consume resources for 10 min and ends in too high cost)

Function 3: ???

• ???
• check states and detect 10 minutes delay
  • fire OBJECT-10min-started event

...

> To react 10 minutes AFTER a event happend.

First I will emphasize that events should represent something that has taken place in the past and not what will take place in the future. The expectation for events is to notify about what has happened.

Second, if you have an expectation of what needs to happen, a command is better than an event. In this case, you want the work to happen in 10 minutes on the blob that would be in the state it's actually available for work. I would respond to the event by sending a delayed message to a queue (Azure Service Bus) with the information needed to work on the blob. That way you're responding to the event by preparing a future/delayed work item.

> how to postponed event fire or event receive in azure event grid?

The Azure Event Grid (AEG) doesn't have built in this feature, however is very easy to extent it using an Azure Service Bus (ASB) entities for delayed (scheduled) message like is mentioned in the answer by Sean.

The following screen snippet shows a concept of the Push-and-Pull with delay subscriber:

The event message is pushed into the ASB topic and based on its subscription rule, the event message is forwarded to the queue entity as a scheduled message.

The topic subscription requires to setup the following properties:

• ForwardTo

  name of the queue/topic entity
  

• $Default Rule

  Filter:

  1=1 
  

  Action (example for 10 minutes):

  SET sys.TimeToLive = '00:10:00';
  SET EnqueuedTimeUtc = sys.EnqueuedTimeUtc;
  SET ScheduledEnqueueTimeUtc = sys.ExpiresAtUtc;
  SET sys.ScheduledEnqueueTimeUtc = sys.ExpiresAtUtc;
  SET sys.Label = 'Delay';
  SET sys.TimeToLive = '01:00:00';
  

Destination queue:

 EnableDeadLetteringOnMessageExpiration = true

Based on the above setting, the scheduled message in the queue must be consumed within the TTL such as '01:00:00', otherwise the message is sent to the DLQ. More details in the Sean's comment.

Using the ServiceBusTrigger function, the delayed event message can be pulled from the queue in the transparent manner like AEG subscriber.

In the case, when the delayed event is sent back to the AEG for Fan-Out distributing and using a Push-and-Push pattern, the following example shows this implementation of the ServiceBusTrigger with an output binding to the AEG custom topic:

run.csx:

#r "Newtonsoft.Json"
#r "Microsoft.Azure.EventGrid"
#r "Microsoft.Azure.ServiceBus"


using System.Net;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Azure.ServiceBus;


public static async Task Run(Message queueItem, IAsyncCollector<EventGridEvent> outputEvents, ILogger log)
{   
    string jsontext = JToken.Parse(Encoding.UTF8.GetString(queueItem.Body)).ToString(Formatting.Indented); 
    log.LogInformation(jsontext);

    EventGridEvent eventGridEvent = JsonConvert.DeserializeObject<EventGridEvent>(jsontext);
    eventGridEvent.Topic = null;
    eventGridEvent.Subject += "/delayed";
    await outputEvents.AddAsync(eventGridEvent);

    await Task.CompletedTask;
}

function.json:

{
  "bindings": [
    {
      "name": "queueItem",
      "type": "serviceBusTrigger",
      "direction": "in",
      "queueName": "aeg",
      "connection": "rk2016_SERVICEBUS"
    },
    {
      "type": "eventGrid",
      "direction": "out",
      "name": "outputEvents",
      "topicEndpointUri": "AEG_TOPIC_XX_ENDPOINT",
      "topicKeySetting": "AEG_TOPIC_XX_KEY"
    }
  ]
}

As you can see, the subject property has been modified with suffix /delayed for filtering purposes such as avoiding a looping, etc.