Run the timer immediately when enabled is set to true from the settings view

Author: shana

src/GitHub.Api/ApplicationManagerBase.cs

@@ -164,8 +164,7 @@ protected void SetupMetrics(string unityVersion, bool firstRun)
                 UserSettings.Set(Constants.GuidKey, id);
             }
 
-            UsageTracker = new UsageTracker(usagePath, id, unityVersion);
-            UsageTracker.Enabled = UserSettings.Get(Constants.MetricsKey, true);
+            UsageTracker = new UsageTracker(UserSettings, usagePath, id, unityVersion);
 
             if (firstRun)
             {

src/GitHub.Api/Metrics/UsageTracker.cs

@@ -3,8 +3,9 @@
 using System.Text;
 using System.Threading.Tasks;
 using System.Timers;
-using Rackspace.Threading;
 using System.Globalization;
+using System.Threading;
+using Timer = System.Threading.Timer;
 
 namespace GitHub.Unity
 {
@@ -14,20 +15,21 @@ class UsageTracker : IUsageTracker
         private static IMetricsService metricsService;
 
         private readonly NPath storePath;
+        private readonly ISettings userSettings;
         private readonly string guid;
         private readonly string unityVersion;
-
-        private bool firstRun = true;
         private Timer timer;
 
-        public UsageTracker(NPath storePath, string guid, string unityVersion)
+        public UsageTracker(ISettings userSettings, NPath storePath, string guid, string unityVersion)
         {
+            this.userSettings = userSettings;
             this.guid = guid;
             this.storePath = storePath;
             this.unityVersion = unityVersion;
 
             Logger.Trace("guid:{0}", guid);
-            RunTimer();
+            if (Enabled)
+                RunTimer(3*60);
         }
 
         private UsageStore LoadUsage()
@@ -88,98 +90,71 @@ private void SaveUsage(UsageStore store)
             }
         }
 
-        private void RunTimer()
-        {
-            Logger.Trace("Scheduling timer for 3 minutes from now");
-            // The timer first ticks after 3 minutes to allow things to settle down after startup.
-            // This will be changed to 8 hours after the first tick by the TimerTick method.
-            timer = new Timer(TimeSpan.FromMinutes(3).TotalMilliseconds);
-            timer.Elapsed += TimerTick;
-            timer.Start();
-        }
-            
-        private void TimerTick(object sender, ElapsedEventArgs e)
+        private void RunTimer(int seconds)
         {
-            TimerTick().Catch((Action<Task, Exception>)((task, exception) => {
-                Logger.Error(exception, "TimerTicker Error: {0}", exception.Message);
-            })).Forget();
+            Logger.Trace($"Scheduling timer for {seconds} seconds from now");
+            timer = new Timer(async _ =>
+            {
+                try
+                {
+                    timer.Dispose();
+                    await SendUsage();
+                }
+                catch {}
+            }, null, seconds * 1000, Timeout.Infinite);
         }
 
-        private async Task TimerTick()
-        {
-            Logger.Trace("TimerTick");
 
-            var usageStore = LoadUsage();
+        private async Task SendUsage()
+        {
+            Logger.Trace("SendUsage");
 
-            if (firstRun)
-            {
-                timer.Interval = TimeSpan.FromHours(8).TotalMilliseconds;
-                firstRun = false;
-                Logger.Trace("Scheduling timer for 8 hours from now");
-
-                if (!Enabled)
-                {
-                    Logger.Warning("Metrics Disabled");
-                    return;
-                }
-            }
+            var usage = LoadUsage();
 
             if (metricsService == null)
             {
-                Logger.Warning("MetricsClient is null; stopping timer");
-                if (timer != null)
-                {
-                    timer.Enabled = false;
-                    timer = null;
-                }
-                return;
-            }
-
-            if (!Enabled)
-            {
-                Logger.Warning("Metrics Disabled");
+                Logger.Warning("No service, not sending usage");
                 return;
             }
 
-            if (usageStore.LastUpdated.Date != DateTimeOffset.UtcNow.Date)
+            if (usage.LastUpdated.Date != DateTimeOffset.UtcNow.Date)
             {
-                await SendUsage(usageStore);
-            }
-        }
+                Logger.Trace("Sending Usage");
 
-        private async Task SendUsage(UsageStore usage)
-        {
-            Logger.Trace("Sending Usage");
-
-            var currentTimeOffset = DateTimeOffset.UtcNow;
-            var beforeDate = currentTimeOffset.Date;
+                var currentTimeOffset = DateTimeOffset.UtcNow;
+                var beforeDate = currentTimeOffset.Date;
 
-            var success = false;
-            var extractReports = usage.Model.SelectReports(beforeDate);
-            if (!extractReports.Any())
-            {
-                Logger.Trace("No items to send");
-                success = true;
-            }
-            else
-            {
-                try
+                var success = false;
+                var extractReports = usage.Model.SelectReports(beforeDate);
+                if (!extractReports.Any())
                 {
-                    await metricsService.PostUsage(extractReports);
-                    success = true;
+                    Logger.Trace("No items to send");
                 }
-                catch (Exception ex)
+                else
                 {
-                    Logger.Warning(ex, "Error Sending Usage");
-                }
+                    if (!Enabled)
+                    {
+                        Logger.Trace("Metrics disabled");
+                        return;
+                    }
 
-            }
+                    try
+                    {
+                        await metricsService.PostUsage(extractReports);
+                        success = true;
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.Warning(ex, "Error Sending Usage");
+                    }
+                }
 
-            if (success)
-            {
-                usage.Model.RemoveReports(beforeDate);
-                usage.LastUpdated = currentTimeOffset;
-                SaveUsage(usage);
+                if (success)
+                {
+                    usage.Model.RemoveReports(beforeDate);
+                    usage.LastUpdated = currentTimeOffset;
+                    SaveUsage(usage);
+                }
             }
         }
 
@@ -204,6 +179,27 @@ public static void SetMetricsService(IMetricsService instance)
             metricsService = instance;
         }
 
-        public bool Enabled { get; set; }
+        public bool Enabled
+        {
+            get
+            {
+                return userSettings.Get(Constants.MetricsKey, true);
+            }
+            set
+            {
+                if (value == Enabled)
+                    return;
+                userSettings.Set(Constants.MetricsKey, value);
+                if (value)
+                {
+                    RunTimer(5);
+                }
+                else
+                {
+                    timer.Dispose();
+                    timer = null;
+                }
+            }
+        }
     }
 }

src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs

@@ -678,8 +678,7 @@ private void OnPrivacyGui()
             }
             if (EditorGUI.EndChangeCheck())
             {
-                EntryPoint.UsageTracker.Enabled = metricsEnabled;
-                Manager.UserSettings.Set(Constants.MetricsKey, metricsEnabled);
+                Manager.UsageTracker.Enabled = metricsEnabled;
             }
 
             GUI.enabled = true;