Is it possible to explicitly ask from JetStream to (re)send the last few messages it received in subject foo.*?

[dsidirop]

Forward Clarification: I understand that the operations I'm referring to are not exactly "mainstream" but they could come in handy in certain situations (N-Message Replay in low-traffic backends). I'm just thinking out loud here so please bare with me.

To get all the messages that JetStream holds within the last 1.5second we can do something like this:

   now := time.Now()
   oneAndHalfSecondAgo := now.Add(time.Millisecond * -1500)

   js, _ := nc.JetStream()
   sub, err := js.SubscribeSync(
        "foo.*",
        nats.OrderedConsumer(),
        nats.StartTime(oneAndHalfSecondAgo),
   )

   for {
       msg, err := sub.NextMsg(10 * time.Second) //oldest->newer ones
       if err != nil {
           log.Fatal(err)
       }

       // 1. check timestamp of message and if its after ‘now’ then we break out of the for loop here

       // 2. if the message is before now we can push it in an array here
   }

Questions:

1. Is it possible to also place an upper-bound limit too? For example:

   sub, err := js.SubscribeSync(
        "foo.*",
        nats.OrderedConsumer(),
        nats.StartTime(oneAndHalfSecondAgo),
        nats.EndTime(now),    <--- any chance of supporting this?
   )
   

2. Is it possible to introduce a "single-fetch" version of SubscribeSync() called 'ScoopSync()' or something? This method will bring the whole array of results in one go (instead of requesting .NextMsg() again and again making multiple fetches from the server). I suspect that there is a chance that this approach doesn't bode really well with how Jetstream's event-log should be operated upon so I'd be happy to stand corrected in this regard :)

   results, err := js.ScoopSync(    <--- results is an array[] now
        "foo.*",
        nats.StartTime(oneAndHalfSecondAgo),
        nats.EndTime(now),    <--- let's assume that this is indeed supported
   )
   

3. Is it possible to request the last N-messages from a certain moment of time and on?

   results, err := js.ScoopSync(
        "foo.*",
        nats.OrderedConsumer(),
        nats.StartTime(oneAndHalfSecondAgo),
        nats.NumberOfMessages(17), <--- any chance of supporting this?
   )
   
   This will only fetch 17 messages - no more. If only 8 messages can be found at that particular moment then it will return just 8.
   

Thank you for everything and keep up the good work guys - NATS is awesome!

[jnmoyne]

One thing would do what you want: an ephemeral pull consumer (and a tiny bit of code in your application to do the check of the timestamp) to know when to stop using that consumer...
... the client API doesn't offer the ability to create an ephemeral pull consumer (yet) but that you could emulate the functionality yourself by doing the following in your application code:

• programmatically defining a 'temporary' durable pull consumer by using a unique random name
• then using it by subscribing from it and using Fetch() to iterate through the result set until you get X messages (Race conditions in gnatsd #3 above)
• call fetch in a loop util you get a message with a time stamp > when you created that pull consumer (Allow enabling and disabling of logging. #1 above)
• and you can even specify a 'max batch size' in your Fetch() call if you want (Add ready message after net.Listen succeeded #2 above)
• programmatically remove that temporary durable pull consumer

Should be all pretty easy to implement