I'd like to be able to make a call (e.g., to an API) from within an Azure function, and make a log entry if it is taking longer than n milliseconds, but not interrupt or end the call. Note this is not for the UI, it would only be for logging.
How can I do this in C#?
Here is an application-agnostic solution (not tailored specifically for Azure).
static IDisposable CreateSlowCallLogger(string title, int dueTimeMilliseconds = 1000)
{
System.Threading.Timer timer = new(_ =>
{
// Log the slow call
Console.WriteLine($"{title} was slower than {dueTimeMilliseconds:#,0} msec!");
});
timer.Change(dueTimeMilliseconds, Timeout.Infinite);
return timer;
}
Usage example:
using (CreateSlowCallLogger("TheAPI"))
{
TheAPI();
}
The above implementation logs the slow call on a ThreadPool thread, while the call is still running. So there is no information available about how long the call lasted from start to finish. If you want this information you could implement something similar using a Stopwatch instead of a Timer, and logging synchronously after the completion of the call.
TheAPI() takes more than 1 second to complete. Otherwise it doesn't log.
TimeProvider.CreateTimer would be beneficial. Also mentioning that Dispose()ing cancels the timer.TimeProvider because I've never used it. Feel free to edit my answer and make these two improvements if you want.I'm not sure if it has already been proposed in part by one of the other answers. However, unless you want the log message to appear exactly at the time of the threshold, you can simply start a Stopwatch before the request. After the request is successful or failed, you log if Elapsed is more than the threshold.
Azure portal has metrics that will give you execution times and you can setup alerts for when execution times start to exceed thresholds. Trying to add this kind of monitoring and notification in your function seems like a lot of work.
If you were so inclined to do this in code, whenever your function was invoked, a second thread would have to be created that would check to see if the main thread's execution has exceeded your desired time. Trying to synchronize this and do it properly would get messy real quick.
If its just for logging the execution time, I would just emit the log statement once the function was complete.
Task, see On awaiting a task with a timeout in C# and WaitAsync(TimeSpan)Create two competing tasks: the actual API call and a simple time delay representing your threshold.
int thresholdMs = 2000; // Your N milliseconds
var apiCallTask = HttpClient.GetAsync(url); // The API call task
var delayTask = Task.Delay(thresholdMs); // The monitoring timer
Use Task.WhenAny to wait for the fastest task. If the delay finishes first, the API call has exceeded the threshold, and you log a warning.
var completedTask = await Task.WhenAny(apiCallTask, delayTask);
if (completedTask == delayTask)
{
// LOG ENTRY: The threshold was breached.
// The apiCallTask is still running in the background.
log.LogWarning("API call is slow, still waiting...");
}
Regardless of whether the warning was logged, you must always await the original apiCallTask to make sure the call finishes and its result is handled.
// Wait for the API call to finally finish
try
{
var response = await apiCallTask;
// ... process final result
}
catch (Exception ex)
{
// ... handle exceptions
}
Advice. There can be a lot of ways to handle this. I'd start with Activity/ActivitySource just for the abstractions, and either check for long calls in whatever monitoring I use, or create a custom listener that triggers a notification or log if an activity isn't finished/disposes in X seconds.