fix: resolve 10 critical monitoring service issues

Author: hemanandr

ThingConnect.Pulse.Server/Controllers/AuthController.cs

@@ -3,6 +3,7 @@
 using Microsoft.AspNetCore.Mvc;
 using ThingConnect.Pulse.Server.Data;
 using ThingConnect.Pulse.Server.Models;
+using ThingConnect.Pulse.Server.Services;
 
 namespace ThingConnect.Pulse.Server.Controllers;
 
@@ -13,15 +14,18 @@ public sealed class AuthController : ControllerBase
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly SignInManager<ApplicationUser> _signInManager;
     private readonly ILogger<AuthController> _logger;
+    private readonly ISettingsService _settingsService;
 
     public AuthController(
         UserManager<ApplicationUser> userManager,
         SignInManager<ApplicationUser> signInManager,
-        ILogger<AuthController> logger)
+        ILogger<AuthController> logger,
+        ISettingsService settingsService)
     {
         _userManager = userManager;
         _signInManager = signInManager;
         _logger = logger;
+        _settingsService = settingsService;
     }
 
     /// <summary>
@@ -118,7 +122,14 @@ public async Task<ActionResult<UserInfoDto>> RegisterAsync([FromBody] RegisterRe
                 return BadRequest(new { message = "Registration failed", errors });
             }
 
-            _logger.LogInformation("Initial admin user created: {Username} (ID: {UserId})", user.UserName, user.Id);
+            // Sign in the user immediately after successful registration
+            await _signInManager.SignInAsync(user, isPersistent: true);
+            
+            // Update last login time since we just signed them in
+            user.LastLoginAt = DateTimeOffset.UtcNow;
+            await _userManager.UpdateAsync(user);
+
+            _logger.LogInformation("Initial admin user created and signed in: {Username} (ID: {UserId})", user.UserName, user.Id);
 
             return Ok(new UserInfoDto
             {
@@ -250,4 +261,53 @@ public async Task<IActionResult> LogoutAsync()
             return StatusCode(500, new { message = "Internal server error" });
         }
     }
+
+    /// <summary>
+    /// Save telemetry consent settings during onboarding
+    /// </summary>
+    [HttpPost("telemetry-consent")]
+    public async Task<IActionResult> SaveTelemetryConsentAsync([FromBody] TelemetryConsentDto request)
+    {
+        try
+        {
+            // Save telemetry consent settings
+            await _settingsService.SetAsync("telemetry_error_diagnostics", request.ErrorDiagnostics.ToString().ToLowerInvariant());
+            await _settingsService.SetAsync("telemetry_usage_analytics", request.UsageAnalytics.ToString().ToLowerInvariant());
+            await _settingsService.SetAsync("telemetry_consent_timestamp", DateTimeOffset.UtcNow);
+
+            _logger.LogInformation("Telemetry consent saved: ErrorDiagnostics={ErrorDiagnostics}, UsageAnalytics={UsageAnalytics}",
+                request.ErrorDiagnostics, request.UsageAnalytics);
+
+            return Ok(new { message = "Telemetry consent saved successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error saving telemetry consent");
+            return StatusCode(500, new { message = "Internal server error" });
+        }
+    }
+
+    /// <summary>
+    /// Get current telemetry consent settings
+    /// </summary>
+    [HttpGet("telemetry-consent")]
+    public async Task<ActionResult<TelemetryConsentDto>> GetTelemetryConsentAsync()
+    {
+        try
+        {
+            string? errorDiagnostics = await _settingsService.GetAsync("telemetry_error_diagnostics");
+            string? usageAnalytics = await _settingsService.GetAsync("telemetry_usage_analytics");
+
+            return Ok(new TelemetryConsentDto
+            {
+                ErrorDiagnostics = bool.TryParse(errorDiagnostics, out bool errorValue) && errorValue,
+                UsageAnalytics = bool.TryParse(usageAnalytics, out bool usageValue) && usageValue
+            });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting telemetry consent");
+            return StatusCode(500, new { message = "Internal server error" });
+        }
+    }
 }

ThingConnect.Pulse.Server/Models/AuthDtos.cs

@@ -101,4 +101,10 @@ public sealed class ChangePasswordDto
     [Required]
     [Compare("NewPassword")]
     public string ConfirmPassword { get; set; } = default!;
+}
+
+public sealed class TelemetryConsentDto
+{
+    public bool ErrorDiagnostics { get; set; }
+    public bool UsageAnalytics { get; set; }
 }

ThingConnect.Pulse.Server/Services/Monitoring/MonitorState.cs

@@ -5,9 +5,11 @@ namespace ThingConnect.Pulse.Server.Services.Monitoring;
 /// <summary>
 /// Per-endpoint in-memory state for outage detection and flap damping.
 /// Tracks success/fail streaks and manages state transitions.
+/// Thread-safe with internal locking.
 /// </summary>
 public sealed class MonitorState
 {
+    private readonly object _lock = new object();
     /// <summary>
     /// The last publicly reported status (UP/DOWN). Null if never determined.
     /// </summary>
@@ -40,12 +42,19 @@ public sealed class MonitorState
     /// </summary>
     public bool ShouldTransitionToDown(int threshold = 2)
     {
-        // If never initialized, transition immediately on first failure
-        if (LastPublicStatus == null && FailStreak >= 1)
-            return true;
+        lock (_lock)
+        {
+            // Must have enough failures to trigger transition
+            if (FailStreak < Math.Max(1, threshold))
+                return false;
+                
+            // Handle null status (never initialized) - transition on first failure
+            if (LastPublicStatus == null)
+                return FailStreak >= 1;
 
-        // Otherwise require threshold for state change from UP to DOWN
-        return LastPublicStatus != UpDown.down && FailStreak >= threshold;
+            // Only transition if currently UP (not already DOWN)
+            return LastPublicStatus == UpDown.up;
+        }
     }
 
     /// <summary>
@@ -55,49 +64,96 @@ public bool ShouldTransitionToDown(int threshold = 2)
     /// </summary>
     public bool ShouldTransitionToUp(int threshold = 2)
     {
-        // If never initialized, transition immediately on first success
-        if (LastPublicStatus == null && SuccessStreak >= 1)
-            return true;
+        lock (_lock)
+        {
+            // Must have enough successes to trigger transition
+            if (SuccessStreak < Math.Max(1, threshold))
+                return false;
+                
+            // Handle null status (never initialized) - transition on first success
+            if (LastPublicStatus == null)
+                return SuccessStreak >= 1;
 
-        // Otherwise require threshold for state change from DOWN to UP
-        return LastPublicStatus != UpDown.up && SuccessStreak >= threshold;
+            // Only transition if currently DOWN (not already UP)
+            return LastPublicStatus == UpDown.down;
+        }
     }
 
     /// <summary>
     /// Records a successful check result and updates streaks.
     /// </summary>
     public void RecordSuccess()
     {
-        SuccessStreak++;
-        FailStreak = 0;
+        lock (_lock)
+        {
+            SuccessStreak++;
+            FailStreak = 0;
+        }
     }
 
     /// <summary>
     /// Records a failed check result and updates streaks.
     /// </summary>
     public void RecordFailure()
     {
-        FailStreak++;
-        SuccessStreak = 0;
+        lock (_lock)
+        {
+            FailStreak++;
+            SuccessStreak = 0;
+        }
     }
 
     /// <summary>
     /// Transitions the state to DOWN and records the change timestamp.
     /// </summary>
     public void TransitionToDown(long timestamp, long outageId)
     {
-        LastPublicStatus = UpDown.down;
-        LastChangeTs = timestamp;
-        OpenOutageId = outageId;
+        lock (_lock)
+        {
+            LastPublicStatus = UpDown.down;
+            LastChangeTs = timestamp;
+            OpenOutageId = outageId;
+        }
     }
 
     /// <summary>
     /// Transitions the state to UP and records the change timestamp.
     /// </summary>
     public void TransitionToUp(long timestamp)
     {
-        LastPublicStatus = UpDown.up;
-        LastChangeTs = timestamp;
-        OpenOutageId = null;
+        lock (_lock)
+        {
+            LastPublicStatus = UpDown.up;
+            LastChangeTs = timestamp;
+            OpenOutageId = null;
+        }
+    }
+
+    /// <summary>
+    /// Restores streak counters to previous values (used for rollback on transaction failures).
+    /// </summary>
+    public void RestoreStreakCounters(int successStreak, int failStreak)
+    {
+        lock (_lock)
+        {
+            SuccessStreak = successStreak;
+            FailStreak = failStreak;
+        }
+    }
+
+    /// <summary>
+    /// Validates that transition logic maintains mutual exclusivity.
+    /// This is used for debugging and ensuring state machine correctness.
+    /// </summary>
+    public bool ValidateTransitionMutualExclusivity(int threshold = 2)
+    {
+        lock (_lock)
+        {
+            bool shouldTransitionDown = ShouldTransitionToDown(threshold);
+            bool shouldTransitionUp = ShouldTransitionToUp(threshold);
+            
+            // Both transitions should never be true simultaneously
+            return !(shouldTransitionDown && shouldTransitionUp);
+        }
     }
 }