Record for how long a command executes

src/PixiEditor/Models/AnalyticsAPI/AnalyticEvent.cs

@@ -2,11 +2,32 @@
 
 public class AnalyticEvent
 {
+    private Semaphore? _endTimeReportedSemaphore;
+    
     public string EventType { get; set; }
     
     public DateTime Time { get; set; }
     
     public DateTime End { get; set; }
     
+    public bool ExpectingEndTimeReport { get; set; }
+
+    public void ReportEndTime()
+    {
+        End = DateTime.UtcNow;
+        ExpectingEndTimeReport = false;
+        
+        _endTimeReportedSemaphore?.Release();
+    }
+
+    public void WaitForEndTime(TimeSpan timeout)
+    {
+        _endTimeReportedSemaphore = new Semaphore(0, int.MaxValue);
+
+        _endTimeReportedSemaphore.WaitOne(timeout);
+        _endTimeReportedSemaphore?.Dispose();
+        _endTimeReportedSemaphore = null;
+    }
+    
     public Dictionary<string, object>? Data { get; set; }
 }

src/PixiEditor/Models/AnalyticsAPI/Analytics.cs

@@ -40,13 +40,16 @@ public static class Analytics
     internal static AnalyticEvent? SendSwitchToTool(IToolHandler? newTool, IToolHandler? oldTool, ICommandExecutionSourceInfo? sourceInfo) =>
         SendEvent(AnalyticEventTypes.SwitchTool, ("NewTool", newTool?.ToolName), ("OldTool", oldTool?.ToolName), ("Source", sourceInfo));
 
-    internal static AnalyticEvent? SendCommand(string commandName, ICommandExecutionSourceInfo? source) =>
-        source is ShortcutSourceInfo { IsRepeat: true } ? null : SendEvent(AnalyticEventTypes.GeneralCommand, ("CommandName", commandName), ("Source", source));
+    internal static AnalyticEvent? SendCommand(string commandName, ICommandExecutionSourceInfo? source, bool expectingEndTime = false) =>
+        source is ShortcutSourceInfo { IsRepeat: true } ? null : SendEvent(AnalyticEventTypes.GeneralCommand, expectingEndTime, ("CommandName", commandName), ("Source", source));
 
     private static AnalyticEvent? SendEvent(string name, params (string, object)[] data) =>
         SendEvent(name, data.ToDictionary());
+    
+    private static AnalyticEvent? SendEvent(string name, bool expectingEndTime, params (string, object)[] data) =>
+        SendEvent(name, data.ToDictionary(), expectingEndTime);
 
-    private static AnalyticEvent? SendEvent(string name, Dictionary<string, object> data)
+    private static AnalyticEvent? SendEvent(string name, Dictionary<string, object> data, bool expectingEndTime = false)
     {
         var reporter = AnalyticsPeriodicReporter.Instance;
 
@@ -59,6 +62,7 @@ public static class Analytics
         {
             EventType = name,
             Time = DateTime.UtcNow,
+            ExpectingEndTimeReport = expectingEndTime,
             Data = data
         };
         

src/PixiEditor/Models/AnalyticsAPI/AnalyticsPeriodicReporter.cs

@@ -92,6 +92,9 @@ public class AnalyticsPeriodicReporter
         {
             try
             {
+                if (_backlog.Any(x => x.ExpectingEndTimeReport))
+                    WaitForEndTimes();
+                
                 await SendBacklogAsync();
 
                 await Task.Delay(TimeSpan.FromSeconds(10));
@@ -104,6 +107,23 @@ public class AnalyticsPeriodicReporter
         }
     }
 
+    private void WaitForEndTimes()
+    {
+        var totalTimeout = DateTime.Now + TimeSpan.FromSeconds(10);
+
+        foreach (var backlog in _backlog)
+        {
+            var timeout = totalTimeout - DateTime.Now;
+
+            if (timeout < TimeSpan.Zero)
+            {
+                break;
+            }
+
+            backlog.WaitForEndTime(timeout);
+        }
+    }
+
     private async Task SendBacklogAsync()
     {
         await _semaphore.WaitAsync();

src/PixiEditor/Models/Commands/CommandController.cs

@@ -372,17 +372,25 @@ internal class CommandController
     private static void CommandMethodInvoker(MethodInfo method, string name, object? instance, object parameter, ParameterInfo[] parameterInfos, bool isTracking)
     {
         var parameters = GetParameters(parameter, parameterInfos);
+        AnalyticEvent? analytics = null;
                 
         if (isTracking)
         {
-            Analytics.SendCommand(name, (parameter as CommandExecutionContext)?.SourceInfo);
+            analytics = Analytics.SendCommand(name, (parameter as CommandExecutionContext)?.SourceInfo, expectingEndTime: true);
         }
 
         try
         {
             object result = method.Invoke(instance, parameters);
             if (result is Task task)
+            {
                 task.ContinueWith(ActionOnException, TaskContinuationOptions.OnlyOnFaulted);
+                task.ContinueWith(ReportEndTime, TaskContinuationOptions.OnlyOnRanToCompletion);
+            }
+            else
+            {
+                analytics?.ReportEndTime();
+            }
         }
         catch (TargetInvocationException e)
         {
@@ -398,6 +406,12 @@ internal class CommandController
             await faultedTask; // this instantly throws the exception from the already faulted task
         }
 
+        ValueTask ReportEndTime(Task originalTask)
+        {
+            analytics?.ReportEndTime();
+            return ValueTask.CompletedTask;
+        }
+
         static object?[]? GetParameters(object parameter, ParameterInfo[] parameterInfos)
         {
             object?[]? parameters;