Fix RTT value propagation and logging

- Updated OutageDetectionService to ensure LastRttMs is updated
- Modified StatusController to return full API response
- Adjusted logging configuration
- Verified RTT value tracking across backend services

🐛 Resolves issue with RTT value display on dashboard
🔍 Improved logging for monitoring services

Author: gokulvij

ThingConnect.Pulse.Server/Controllers/StatusController.cs

@@ -32,7 +32,7 @@ public async Task<ActionResult<LiveStatusItemDto>> GetLiveStatusAsync(
     {
         try
         {
-            _logger.LogInformation("Getting live status - group: {Group}, search: {Search}, page: {Page}, pageSize: {PageSize}",
+            _logger.LogInformation("Getting live status - group: {Group}, search: {Search}",
                 group, search);
 
             var result = await _statusService.GetLiveStatusAsync(group, search);

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

@@ -519,6 +519,20 @@ private async Task SaveCheckResultAsync(CheckResult result, CancellationToken ca
         };
 
         _context.CheckResultsRaw.Add(rawResult);
+
+        // Update LastRttMs for successful probes
+        if (result.Status == UpDown.up && result.RttMs.HasValue)
+        {
+            Data.Endpoint? endpoint = await _context.Endpoints.FindAsync([result.EndpointId], cancellationToken);
+            if (endpoint != null)
+            {
+                endpoint.LastRttMs = result.RttMs.Value;
+                _logger.LogInformation(
+                    "Updated LastRttMs for endpoint {EndpointId} to {RttMs}ms",
+                    result.EndpointId, result.RttMs.Value);
+            }
+        }
+
         await _context.SaveChangesAsync(cancellationToken);
     }
 
@@ -539,9 +553,28 @@ public async Task SaveCheckResultsBatchAsync(IEnumerable<CheckResult> results, C
         if (rawResults.Count > 0)
         {
             _context.CheckResultsRaw.AddRange(rawResults);
+
+            // Update LastRttMs for successful probes
+            var successfulRttResults = results
+                .Where(r => r.Status == UpDown.up && r.RttMs.HasValue)
+                .ToList();
+
+            foreach (var result in successfulRttResults)
+            {
+                Data.Endpoint? endpoint = await _context.Endpoints.FindAsync([result.EndpointId], cancellationToken);
+                if (endpoint != null)
+                {
+                    endpoint.LastRttMs = result.RttMs.Value;
+                    _logger.LogInformation(
+                        "Updated LastRttMs for endpoint {EndpointId} to {RttMs}ms",
+                        result.EndpointId, result.RttMs.Value);
+                }
+            }
+
             await _context.SaveChangesAsync(cancellationToken);
 
-            _logger.LogDebug("Batch saved {Count} check results", rawResults.Count);
+            _logger.LogDebug("Batch saved {Count} check results, updated {RttCount} RTT values",
+                rawResults.Count, successfulRttResults.Count);
         }
     }
 }

ThingConnect.Pulse.Server/Services/StatusService.cs

@@ -88,6 +88,10 @@ public async Task<List<LiveStatusItemDto>> GetLiveStatusAsync(string? group, str
                 ? sparklineData[endpoint.Id]
                 : new List<SparklinePoint>();
 
+            _logger.LogInformation(
+                "Endpoint {EndpointName}: Status = {Status}, LastRttMs = {RttMs}, LastChangeTs = {LastChangeTs}",
+                endpoint.Name, status, endpoint.LastRttMs, endpoint.LastChangeTs);
+
             items.Add(new LiveStatusItemDto
             {
                 Endpoint = MapToEndpointDto(endpoint),

docs/rtt-tracing.md

@@ -0,0 +1,88 @@
+# RTT Value Tracing and Investigation
+
+## RTT Journey Flow Diagram
+
+```mermaid
+graph TD
+    A[Probe Service] -->|Measure RTT| B[CheckResult]
+    B -->|RttMs| C[MonitoringBackgroundService]
+    C -->|Update Endpoint| D[OutageDetectionService]
+    D -->|Persist LastRttMs| E[StatusService]
+    E -->|Serialize RTT| F[API Controller]
+    F -->|Response| G[Frontend Service]
+    G -->|Render| H[Frontend Components]
+
+    subgraph Potential Failure Points
+        A -->|Null/Zero RTT| B
+        B -->|Null RttMs| C
+        C -->|Ignore Null RTT| D
+        D -->|Skip Update| E
+        E -->|Empty RTT| F
+        F -->|Omit RTT| G
+        G -->|Display Placeholder| H
+    end
+```
+
+## RTT Tracing Points
+
+### 1. Probe Service (`ProbeService.cs`)
+- **Probe Types**:
+  - ICMP: Uses `reply.RoundtripTime`
+  - TCP: Uses `stopwatch.ElapsedMilliseconds`
+  - HTTP: Uses `stopwatch.ElapsedMilliseconds`
+- **Failure Handling**:
+  - Sets `RttMs` to null on probe failures
+  - Different measurement methods may introduce inconsistencies
+
+### 2. Background Monitoring Service
+- Logs RTT with trace:
+  ```csharp
+  _logger.LogTrace("Probed endpoint {EndpointId} ({Name}): {Status} in {RttMs}ms")
+  ```
+- Converts null RTT to "N/A"
+
+### 3. Outage Detection Service
+- Copies `result.RttMs` to new records
+- Potential loss point if RTT is null
+
+### 4. Status Service
+- Uses `endpoint.LastRttMs` to populate status responses
+- May return null/empty RTT
+
+### 5. Frontend Service and Components
+- Uses optional chaining and nullish coalescing
+- Handles null RTT with placeholders ('-')
+
+## Investigation Steps
+
+### 1. Probe Measurement Verification
+- [ ] Compare RTT measurements across different probe types
+- [ ] Add detailed logging in `ProbeService`
+- [ ] Verify stopwatch and `RoundtripTime` calculations
+
+### 2. Null Value Propagation Analysis
+- [ ] Trace null RTT through each service layer
+- [ ] Add comprehensive logging
+- [ ] Validate null handling in serialization
+
+### 3. API Contract Validation
+- [ ] Inspect API response DTOs
+- [ ] Check JSON serialization of RTT values
+- [ ] Verify optional/nullable field handling
+
+### 4. Frontend Parsing Investigation
+- [ ] Review TypeScript type definitions
+- [ ] Validate RTT parsing in API services
+- [ ] Test display logic for various RTT scenarios
+
+### 5. Comprehensive Test Scenarios
+- [ ] Successful probe with non-zero RTT
+- [ ] Failed probe (null RTT)
+- [ ] Edge cases: zero, very low, very high RTT values
+- [ ] Multiple probe type comparisons
+
+## Potential Improvement Recommendations
+- Standardize RTT measurement across probe types
+- Implement consistent null/zero RTT handling
+- Add more granular logging and tracing
+- Create comprehensive test suite for RTT propagation