fix stats related bugs of paused monitors (#236)

adamkobor · web-flow · commit eb9d42e45d73 · 2025-08-31T16:38:01.000+02:00
diff --git a/app/src/main/kotlin/com/kuvaszuptime/kuvasz/repositories/IncidentRepository.kt b/app/src/main/kotlin/com/kuvaszuptime/kuvasz/repositories/IncidentRepository.kt
@@ -66,10 +66,13 @@ class IncidentRepository(private val dslContext: DSLContext) {
         .from(HTTP_UPTIME_EVENT)
         .join(HTTP_MONITOR).on(HTTP_UPTIME_EVENT.MONITOR_ID.eq(HTTP_MONITOR.ID))
         .where(HTTP_UPTIME_EVENT.STATUS.eq(UptimeStatus.DOWN))
-        .and(HTTP_MONITOR.ENABLED.isTrue)
         .apply {
             // Filter for monitors
-            monitorId?.let { and(HTTP_MONITOR.ID.eq(it)) }
+            if (monitorId != null) {
+                and(HTTP_MONITOR.ID.eq(monitorId))
+            } else {
+                and(HTTP_MONITOR.ENABLED.isTrue)
+            }
             // Filter for events that were open at any point during the specified period
             period?.let {
                 val periodStart = getCurrentTimestamp().minus(period)
@@ -103,10 +106,13 @@ class IncidentRepository(private val dslContext: DSLContext) {
         .from(SSL_EVENT)
         .join(HTTP_MONITOR).on(SSL_EVENT.MONITOR_ID.eq(HTTP_MONITOR.ID))
         .where(SSL_EVENT.STATUS.eq(SslStatus.INVALID))
-        .and(HTTP_MONITOR.ENABLED.isTrue)
         .apply {
             // Filter for monitors
-            monitorId?.let { and(HTTP_MONITOR.ID.eq(it)) }
+            if (monitorId != null) {
+                and(HTTP_MONITOR.ID.eq(monitorId))
+            } else {
+                and(HTTP_MONITOR.ENABLED.isTrue).and(HTTP_MONITOR.SSL_CHECK_ENABLED.isTrue)
+            }
             // Filter for events that were open at any point during the specified period
             period?.let {
                 val periodStart = getCurrentTimestamp().minus(period)
diff --git a/app/src/main/kotlin/com/kuvaszuptime/kuvasz/services/StatCalculator.kt b/app/src/main/kotlin/com/kuvaszuptime/kuvasz/services/StatCalculator.kt
@@ -102,6 +102,10 @@ class StatCalculator(
         var historicalDowntimeSeconds = 0L
 
         uptimeEvents.forEach { uptimeEvent ->
+            if (!uptimeEvent.isMonitorEnabled && uptimeEvent.updatedAt.isBefore(periodStart)) {
+                // If the monitor was disabled and the last update was before the period then we skip this event
+                return@forEach
+            }
             val effectiveStartDate = maxOf(uptimeEvent.startedAt, periodStart)
             val duration = getDurationOfEvent(
                 isMonitorEnabled = uptimeEvent.isMonitorEnabled,
diff --git a/app/src/test/kotlin/com/kuvaszuptime/kuvasz/repositories/IncidentRepositoryTest.kt b/app/src/test/kotlin/com/kuvaszuptime/kuvasz/repositories/IncidentRepositoryTest.kt
@@ -379,7 +379,7 @@ class IncidentRepositoryTest(
             then("it should return the incident of that monitor only") {
 
                 val monitor1 = createMonitor(httpMonitorRepository)
-                val monitor2 = createMonitor(httpMonitorRepository)
+                val monitor2 = createMonitor(httpMonitorRepository, enabled = false)
 
                 val openDownMonitor1 = createUptimeEventRecord(
                     dslContext,
@@ -410,7 +410,7 @@ class IncidentRepositoryTest(
                     endedAt = getCurrentTimestamp().minusDays(5),
                 )
 
-                createUptimeEventRecord(
+                val openDownMonitor2 = createUptimeEventRecord(
                     dslContext,
                     monitorId = monitor2.id,
                     status = UptimeStatus.DOWN,
@@ -425,7 +425,7 @@ class IncidentRepositoryTest(
                     startedAt = getCurrentTimestamp().minusDays(6),
                     endedAt = getCurrentTimestamp().minusDays(4),
                 )
-                createSSLEventRecord(
+                val openInvalidMonitor2 = createSSLEventRecord(
                     dslContext,
                     monitorId = monitor2.id,
                     status = SslStatus.INVALID,
@@ -458,6 +458,26 @@ class IncidentRepositoryTest(
                     openInvalidSSLMonitor1.status shouldBe IncidentStatus.ONGOING
                     openInvalidSSLMonitor1.incidentType shouldBe IncidentType.SSL
                 }
+
+                // Should return events for the disabled monitor as well
+                val incidentsOfMonitor2 = incidentRepository.getIncidents(
+                    includeResolved = false,
+                    monitorId = monitor2.id,
+                )
+
+                incidentsOfMonitor2 shouldHaveSize 2
+
+                incidentsOfMonitor2.forOne { openMonitor2 ->
+                    openMonitor2.monitorId shouldBe openDownMonitor2.monitorId
+                    openMonitor2.status shouldBe IncidentStatus.ONGOING
+                    openMonitor2.incidentType shouldBe IncidentType.HTTP
+                }
+
+                incidentsOfMonitor2.forOne { openInvalidSSLMonitor2 ->
+                    openInvalidSSLMonitor2.monitorId shouldBe openInvalidMonitor2.monitorId
+                    openInvalidSSLMonitor2.status shouldBe IncidentStatus.ONGOING
+                    openInvalidSSLMonitor2.incidentType shouldBe IncidentType.SSL
+                }
             }
         }
     }
diff --git a/app/src/test/kotlin/com/kuvaszuptime/kuvasz/services/StatCalculatorTest.kt b/app/src/test/kotlin/com/kuvaszuptime/kuvasz/services/StatCalculatorTest.kt
@@ -106,6 +106,90 @@ class StatCalculatorTest(
             }
         }
 
+        `when`("there is a paused monitor - last update before the period") {
+
+            val enabledUpMonitor = createMonitor(monitorRepository, enabled = true)
+            val enabledDownMonitor = createMonitor(monitorRepository, enabled = true)
+            val pausedMonitor = createMonitor(monitorRepository, enabled = false)
+            val now = getCurrentTimestamp()
+
+            // enabledUpMonitor's incidents
+            createUptimeEventRecord(
+                dslContext = dslContext,
+                monitorId = enabledUpMonitor.id,
+                startedAt = now.minusDays(10),
+                status = UptimeStatus.DOWN,
+                endedAt = now.minusDays(5), // 5 days DOWN, 1 day in the period
+            )
+            createUptimeEventRecord(
+                dslContext = dslContext,
+                monitorId = enabledUpMonitor.id,
+                startedAt = now.minusDays(5),
+                status = UptimeStatus.UP,
+                endedAt = null, // 5 days UP
+            )
+            createSSLEventRecord(
+                dslContext = dslContext,
+                monitorId = enabledUpMonitor.id,
+                status = SslStatus.INVALID,
+                startedAt = now.minusDays(10),
+                endedAt = null,
+            )
+            // enabledDownMonitor's incidents
+            createUptimeEventRecord(
+                dslContext = dslContext,
+                monitorId = enabledDownMonitor.id,
+                startedAt = now.minusHours(12),
+                status = UptimeStatus.DOWN,
+                endedAt = null, // 0.5 day DOWN
+            )
+            createSSLEventRecord(
+                dslContext = dslContext,
+                monitorId = enabledDownMonitor.id,
+                status = SslStatus.VALID,
+                startedAt = now.minusDays(10),
+                endedAt = null,
+            )
+            // pausedMonitor's incidents
+            createUptimeEventRecord(
+                dslContext = dslContext,
+                monitorId = pausedMonitor.id,
+                startedAt = now.minusDays(12),
+                status = UptimeStatus.DOWN,
+                endedAt = null,
+                updatedAt = now.minusDays(8),
+            )
+            createSSLEventRecord(
+                dslContext = dslContext,
+                monitorId = pausedMonitor.id,
+                status = SslStatus.VALID,
+                startedAt = now.minusDays(10),
+                endedAt = null,
+                updatedAt = now.minusDays(7)
+            )
+
+            then("it should not count the obsolete events from the paused monitor") {
+                val stats = statCalculator.calculateOverallHttpStats(Duration.ofDays(6))
+                stats.actual.uptimeStats.total shouldBe 3 // 2 enabled monitors + 1 paused monitor
+                stats.actual.uptimeStats.down shouldBe 1
+                stats.actual.uptimeStats.up shouldBe 1
+                stats.actual.uptimeStats.paused shouldBe 1
+                stats.actual.uptimeStats.inProgress shouldBe 0
+
+                stats.actual.sslStats.valid shouldBe 1
+                stats.actual.sslStats.invalid shouldBe 1
+                stats.actual.sslStats.willExpire shouldBe 0
+                stats.actual.sslStats.inProgress shouldBe 0
+
+                stats.history.uptimeStats.incidents shouldBe 2
+                stats.history.uptimeStats.affectedMonitors shouldBe 2
+                // 1.5 days DOWN inside the period
+                stats.history.uptimeStats.totalDowntimeSeconds shouldBe 36 * 60 * 60
+                // 5 days UP, 1.5 days DOWN
+                stats.history.uptimeStats.uptimeRatio shouldBe 5.toDouble() / 6.5
+            }
+        }
+
         `when`("there is a monitor that was just created") {
 
             createMonitor(monitorRepository, enabled = true, sslCheckEnabled = true)
@@ -410,6 +494,7 @@ class StatCalculatorTest(
             val upMonitor = createMonitor(monitorRepository, enabled = true)
             val downMonitor = createMonitor(monitorRepository, enabled = true)
             val pausedMonitor = createMonitor(monitorRepository, enabled = false)
+            val pausedMonitor2 = createMonitor(monitorRepository, enabled = false)
 
             // upMonitor's events: UP
             createUptimeEventRecord(
@@ -447,6 +532,16 @@ class StatCalculatorTest(
                 endedAt = now.minusDays(2),
             )
 
+            // pausedMonitor2's events: DOWN, but update date is before the period, so it should not be counted
+            createUptimeEventRecord(
+                dslContext = dslContext,
+                monitorId = pausedMonitor2.id,
+                startedAt = now.minusDays(10),
+                status = UptimeStatus.DOWN,
+                endedAt = null,
+                updatedAt = now.minusDays(7),
+            )
+
             then("it should correctly calculate the stats for all statuses") {
                 val statsOfInProgressUpMonitor = statCalculator.calculateHistoricalHttpUptimeStats(
                     period = Duration.ofDays(6),
@@ -483,6 +578,15 @@ class StatCalculatorTest(
                 statsOfPausedMonitor.affectedMonitors shouldBe 1
                 statsOfPausedMonitor.totalDowntimeSeconds shouldBe 24 * 60 * 60 // 1 day
                 statsOfPausedMonitor.uptimeRatio shouldBe 0.5
+
+                val statsOfPausedMonitor2 = statCalculator.calculateHistoricalHttpUptimeStats(
+                    period = Duration.ofDays(6),
+                    monitorId = pausedMonitor2.id,
+                )
+                statsOfPausedMonitor2.incidents shouldBe 0
+                statsOfPausedMonitor2.affectedMonitors shouldBe 0
+                statsOfPausedMonitor2.totalDowntimeSeconds shouldBe 0
+                statsOfPausedMonitor2.uptimeRatio shouldBe null
             }
         }
     }
diff --git a/docs/docs/changelog.md b/docs/docs/changelog.md
@@ -1,3 +1,10 @@
+## 3.0.2 <small>2025-08-31</small> { id="3.0.2" data-toc-label="3.0.2" }
+
+### Fixes
+
+- Fixed a bug where the historical HTTP uptime stats could contain incorrect values in case a paused monitor's ongoing incident was updated before the requested time range of stats
+- Fixed a bug where the monitor-specific incidents were not returned in case of a paused monitor
+
 ## 3.0.1 <small>2025-08-31</small> { id="3.0.1" data-toc-label="3.0.1" }
 
 ### Breaking changes
diff --git a/shared/src/main/kotlin/com/kuvaszuptime/kuvasz/util/EventUtils.kt b/shared/src/main/kotlin/com/kuvaszuptime/kuvasz/util/EventUtils.kt
