Implement Slack integration (#36)

kuvasz-uptime · Aug 18, 2020 · a584df1 · a584df1
1 parent fad42c7
commit a584df1
Show file tree

Hide file tree

Showing 19 changed files with 551 additions and 27 deletions.
diff --git a/README.md b/README.md
@@ -23,12 +23,13 @@ Kuvasz (pronounce as [ˈkuvɒs]) is an ancient hungarian breed of livestock & gu
 
 - Uptime & latency monitoring with a configurable interval
 - Email notifications through SMTP
+- Slack notifications through webhoooks
 
 ### Under development 🚧
 
 - SSL certification monitoring
 - Regular Lighthouse audits for your websites
-- Pagerduty, Opsgenie, Slack integration
+- Pagerduty, Opsgenie integration
 - Kuvasz Dashboard, a standalone GUI
 
 ## ⚡️  Quick start guide

diff --git a/docs/kuvasz_avatar.png b/docs/kuvasz_avatar.png
diff --git a/examples/docker-compose/docker-compose.yml b/examples/docker-compose/docker-compose.yml
@@ -26,3 +26,5 @@ services:
       SMTP_FROM_ADDRESS: '[email protected]'
       SMTP_TO_ADDRESS: '[email protected]'
       SMTP_TRANSPORT_STRATEGY: 'SMTP_TLS'
+      ENABLE_SLACK_EVENT_HANDLER: 'true'
+      SLACK_WEBHOOK_URL: 'https://your.slack-webhook.url'
diff --git a/examples/k8s/kuvasz.configmap.yml b/examples/k8s/kuvasz.configmap.yml
@@ -16,3 +16,5 @@ data:
   smtp_from_address: "[email protected]"
   smtp_to_address: "[email protected]"
   smtp_transport_strategy: "SMTP_TLS"
+  slack_event_handler_enabled: "true"
+  slack_webhook_url: "https://your.slack-webhook.url"
diff --git a/examples/k8s/kuvasz.deployment.yaml b/examples/k8s/kuvasz.deployment.yaml
@@ -116,3 +116,13 @@ spec:
                 configMapKeyRef:
                   name: kuvasz-config
                   key: smtp_to_address
+            - name: ENABLE_SLACK_EVENT_HANDLER
+              valueFrom:
+                configMapKeyRef:
+                  name: kuvasz-config
+                  key: slack_event_handler_enabled
+            - name: SLACK_WEBHOOK_URL
+              valueFrom:
+                configMapKeyRef:
+                  name: kuvasz-config
+                  key: slack_webhook_url
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/config/handlers/SlackEventHandlerConfig.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/config/handlers/SlackEventHandlerConfig.kt
@@ -0,0 +1,15 @@
+package com.kuvaszuptime.kuvasz.config.handlers
+
+import com.kuvaszuptime.kuvasz.models.dto.Validation.URI_REGEX
+import io.micronaut.context.annotation.ConfigurationProperties
+import io.micronaut.core.annotation.Introspected
+import javax.inject.Singleton
+import javax.validation.constraints.Pattern
+
+@ConfigurationProperties("handler-config.slack-event-handler")
+@Singleton
+@Introspected
+class SlackEventHandlerConfig {
+    @Pattern(regexp = URI_REGEX)
+    var webhookUrl: String? = null
+}
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/factories/EmailFactory.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/factories/EmailFactory.kt
@@ -1,8 +1,11 @@
 package com.kuvaszuptime.kuvasz.factories
 
 import com.kuvaszuptime.kuvasz.config.handlers.EmailEventHandlerConfig
+import com.kuvaszuptime.kuvasz.models.MonitorDownEvent
+import com.kuvaszuptime.kuvasz.models.MonitorUpEvent
 import com.kuvaszuptime.kuvasz.models.UptimeMonitorEvent
-import com.kuvaszuptime.kuvasz.models.toMessage
+import com.kuvaszuptime.kuvasz.models.toEmoji
+import com.kuvaszuptime.kuvasz.models.toStructuredMessage
 import com.kuvaszuptime.kuvasz.models.toUptimeStatus
 import org.simplejavamail.api.email.Email
 import org.simplejavamail.email.EmailBuilder
@@ -16,11 +19,29 @@ class EmailFactory(private val config: EmailEventHandlerConfig) {
             .buildEmail()
 
     private fun UptimeMonitorEvent.getSubject(): String =
-        "[kuvasz-uptime] - [${monitor.name}] ${monitor.url} is ${toUptimeStatus()}"
+        "[kuvasz-uptime] - ${toEmoji()} [${monitor.name}] ${monitor.url} is ${toUptimeStatus()}"
 
     private fun createEmailBase() =
         EmailBuilder
             .startingBlank()
             .to(config.to, config.to)
             .from(config.from, config.from)
+
+    private fun UptimeMonitorEvent.toMessage() =
+        when (this) {
+            is MonitorUpEvent -> toStructuredMessage().let { details ->
+                listOfNotNull(
+                    details.summary,
+                    details.latency,
+                    details.previousDownTime.orNull()
+                )
+            }
+            is MonitorDownEvent -> toStructuredMessage().let { details ->
+                listOfNotNull(
+                    details.summary,
+                    details.error,
+                    details.previousUpTime.orNull()
+                )
+            }
+        }.joinToString("\n")
 }
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/handlers/LogEventHandler.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/handlers/LogEventHandler.kt
@@ -1,7 +1,7 @@
 package com.kuvaszuptime.kuvasz.handlers
 
 import com.kuvaszuptime.kuvasz.models.RedirectEvent
-import com.kuvaszuptime.kuvasz.models.toMessage
+import com.kuvaszuptime.kuvasz.models.toPlainMessage
 import com.kuvaszuptime.kuvasz.services.EventDispatcher
 import io.micronaut.context.annotation.Context
 import io.micronaut.context.annotation.Requires
@@ -17,10 +17,10 @@ class LogEventHandler @Inject constructor(eventDispatcher: EventDispatcher) {
 
     init {
         eventDispatcher.subscribeToMonitorUpEvents { event ->
-            logger.info(event.toMessage())
+            logger.info(event.toPlainMessage())
         }
         eventDispatcher.subscribeToMonitorDownEvents { event ->
-            logger.error(event.toMessage())
+            logger.error(event.toPlainMessage())
         }
         eventDispatcher.subscribeToRedirectEvents { event ->
             logger.warn(event.toLogMessage())

diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/handlers/SlackEventHandler.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/handlers/SlackEventHandler.kt
@@ -0,0 +1,80 @@
+package com.kuvaszuptime.kuvasz.handlers
+
+import com.kuvaszuptime.kuvasz.models.MonitorDownEvent
+import com.kuvaszuptime.kuvasz.models.MonitorUpEvent
+import com.kuvaszuptime.kuvasz.models.SlackWebhookMessage
+import com.kuvaszuptime.kuvasz.models.UptimeMonitorEvent
+import com.kuvaszuptime.kuvasz.models.runWhenStateChanges
+import com.kuvaszuptime.kuvasz.models.toEmoji
+import com.kuvaszuptime.kuvasz.models.toStructuredMessage
+import com.kuvaszuptime.kuvasz.services.EventDispatcher
+import com.kuvaszuptime.kuvasz.services.SlackWebhookService
+import io.micronaut.context.annotation.Context
+import io.micronaut.context.annotation.Requires
+import io.micronaut.http.HttpResponse
+import io.micronaut.http.client.exceptions.HttpClientResponseException
+import io.micronaut.scheduling.TaskExecutors
+import io.micronaut.scheduling.annotation.ExecuteOn
+import io.reactivex.Flowable
+import org.slf4j.LoggerFactory
+import javax.inject.Inject
+
+@Context
+@Requires(property = "handler-config.slack-event-handler.enabled", value = "true")
+class SlackEventHandler @Inject constructor(
+    private val slackWebhookService: SlackWebhookService,
+    private val eventDispatcher: EventDispatcher
+) {
+    companion object {
+        private val logger = LoggerFactory.getLogger(SlackEventHandler::class.java)
+    }
+
+    init {
+        subscribeToEvents()
+    }
+
+    @ExecuteOn(TaskExecutors.IO)
+    private fun subscribeToEvents() {
+        eventDispatcher.subscribeToMonitorUpEvents { event ->
+            logger.debug("A MonitorUpEvent has been received for monitor with ID: ${event.monitor.id}")
+            event.runWhenStateChanges { slackWebhookService.sendMessage(it.toSlackMessage()).handleResponse() }
+        }
+        eventDispatcher.subscribeToMonitorDownEvents { event ->
+            logger.debug("A MonitorDownEvent has been received for monitor with ID: ${event.monitor.id}")
+            event.runWhenStateChanges { slackWebhookService.sendMessage(it.toSlackMessage()).handleResponse() }
+        }
+    }
+
+    private fun UptimeMonitorEvent.toSlackMessage() = SlackWebhookMessage(text = "${toEmoji()} ${toMessage()}")
+
+    private fun Flowable<HttpResponse<String>>.handleResponse() =
+        subscribe(
+            {
+                logger.debug("A Slack message to your configured webhook has been successfully sent")
+            },
+            { ex ->
+                if (ex is HttpClientResponseException) {
+                    val responseBody = ex.response.getBody(String::class.java)
+                    logger.error("Slack message cannot be sent to your configured webhook: $responseBody")
+                }
+            }
+        )
+
+    private fun UptimeMonitorEvent.toMessage() =
+        when (this) {
+            is MonitorUpEvent -> toStructuredMessage().let { details ->
+                listOfNotNull(
+                    "*${details.summary}*",
+                    "_${details.latency}_",
+                    details.previousDownTime.orNull()
+                )
+            }
+            is MonitorDownEvent -> toStructuredMessage().let { details ->
+                listOfNotNull(
+                    "*${details.summary}*",
+                    "_${details.error}_",
+                    details.previousUpTime.orNull()
+                )
+            }
+        }.joinToString("\n")
+}
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/models/Emoji.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/models/Emoji.kt
@@ -0,0 +1,6 @@
+package com.kuvaszuptime.kuvasz.models
+
+object Emoji {
+    const val ALERT = "🚨"
+    const val CHECK_OK = "✅"
+}
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/models/Event.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/models/Event.kt
@@ -40,12 +40,30 @@ data class RedirectEvent(
     val redirectLocation: URI
 ) : Event()
 
+data class StructuredUpMessage(
+    val summary: String,
+    val latency: String,
+    val previousDownTime: Option<String>
+)
+
+data class StructuredDownMessage(
+    val summary: String,
+    val error: String,
+    val previousUpTime: Option<String>
+)
+
 fun UptimeMonitorEvent.toUptimeStatus(): UptimeStatus =
     when (this) {
         is MonitorUpEvent -> UptimeStatus.UP
         is MonitorDownEvent -> UptimeStatus.DOWN
     }
 
+fun UptimeMonitorEvent.toEmoji(): String =
+    when (this) {
+        is MonitorUpEvent -> Emoji.CHECK_OK
+        is MonitorDownEvent -> Emoji.ALERT
+    }
+
 fun UptimeMonitorEvent.uptimeStatusEquals(previousEvent: UptimeEventPojo) =
     toUptimeStatus() == previousEvent.status
 
@@ -73,24 +91,34 @@ fun UptimeMonitorEvent.runWhenStateChanges(toRun: (UptimeMonitorEvent) -> Unit)
     )
 }
 
-fun UptimeMonitorEvent.toMessage(): String =
-    when (this) {
-        is MonitorUpEvent -> toMessage()
-        is MonitorDownEvent -> toMessage()
+fun MonitorUpEvent.toPlainMessage(): String =
+    toStructuredMessage().let { details ->
+        listOfNotNull(
+            details.summary,
+            details.latency,
+            details.previousDownTime.orNull()
+        ).joinToString(". ")
     }
 
-fun MonitorUpEvent.toMessage(): String {
-    val message = "Your monitor \"${monitor.name}\" (${monitor.url}) is UP (${status.code}). Latency was: ${latency}ms."
-    return getEndedEventDuration().toDurationString().fold(
-        { message },
-        { "$message Was down for $it." }
+fun MonitorUpEvent.toStructuredMessage() =
+    StructuredUpMessage(
+        summary = "Your monitor \"${monitor.name}\" (${monitor.url}) is UP (${status.code})",
+        latency = "Latency: ${latency}ms",
+        previousDownTime = getEndedEventDuration().toDurationString().map { "Was down for $it" }
     )
-}
 
-fun MonitorDownEvent.toMessage(): String {
-    val message = "Your monitor \"${monitor.name}\" (${monitor.url}) is DOWN. Reason: ${error.message}."
-    return getEndedEventDuration().toDurationString().fold(
-        { message },
-        { "$message Was up for $it." }
+fun MonitorDownEvent.toPlainMessage(): String =
+    toStructuredMessage().let { details ->
+        listOfNotNull(
+            details.summary,
+            details.error,
+            details.previousUpTime.orNull()
+        ).joinToString(". ")
+    }
+
+fun MonitorDownEvent.toStructuredMessage() =
+    StructuredDownMessage(
+        summary = "Your monitor \"${monitor.name}\" (${monitor.url}) is DOWN",
+        error = "Reason: ${error.message}",
+        previousUpTime = getEndedEventDuration().toDurationString().map { "Was up for $it" }
     )
-}
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/models/SlackWebhookMessage.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/models/SlackWebhookMessage.kt
@@ -0,0 +1,15 @@
+package com.kuvaszuptime.kuvasz.models
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import java.net.URI
+
+data class SlackWebhookMessage(
+    val username: String = "KuvaszBot",
+    @JsonProperty("icon_url")
+    val iconUrl: URI = URI(ICON_URL),
+    val text: String
+) {
+    companion object {
+        const val ICON_URL = "https://raw.githubusercontent.com/kuvasz-uptime/kuvasz/main/docs/kuvasz_avatar.png"
+    }
+}
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/models/dto/Validation.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/models/dto/Validation.kt
@@ -1,6 +1,6 @@
 package com.kuvaszuptime.kuvasz.models.dto
 
-internal object Validation {
+object Validation {
     const val MIN_UPTIME_CHECK_INTERVAL = 60L
     const val URI_REGEX = "^(https?)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]"
 }
diff --git a/src/main/kotlin/com/kuvaszuptime/kuvasz/services/SlackWebhookService.kt b/src/main/kotlin/com/kuvaszuptime/kuvasz/services/SlackWebhookService.kt
@@ -0,0 +1,38 @@
+package com.kuvaszuptime.kuvasz.services
+
+import com.kuvaszuptime.kuvasz.config.handlers.SlackEventHandlerConfig
+import com.kuvaszuptime.kuvasz.models.SlackWebhookMessage
+import io.micronaut.context.event.ShutdownEvent
+import io.micronaut.core.type.Argument
+import io.micronaut.http.HttpRequest
+import io.micronaut.http.HttpResponse
+import io.micronaut.http.client.RxHttpClient
+import io.micronaut.runtime.event.annotation.EventListener
+import io.reactivex.Flowable
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class SlackWebhookService @Inject constructor(
+    private val slackEventHandlerConfig: SlackEventHandlerConfig,
+    private val httpClient: RxHttpClient
+) {
+
+    companion object {
+        private const val RETRY_COUNT = 3L
+    }
+
+    fun sendMessage(message: SlackWebhookMessage): Flowable<HttpResponse<String>> {
+        val request: HttpRequest<SlackWebhookMessage> = HttpRequest.POST(slackEventHandlerConfig.webhookUrl, message)
+
+        return httpClient
+            .exchange(request, Argument.STRING, Argument.STRING)
+            .retry(RETRY_COUNT)
+    }
+
+    @EventListener
+    @Suppress("UNUSED_PARAMETER")
+    internal fun onShutdownEvent(event: ShutdownEvent) {
+        httpClient.close()
+    }
+}
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
@@ -75,6 +75,9 @@ handler-config:
     enabled: ${ENABLE_SMTP_EVENT_HANDLER:`false`}
     from: ${SMTP_FROM_ADDRESS}
     to: ${SMTP_TO_ADDRESS}
+  slack-event-handler:
+    enabled: ${ENABLE_SLACK_EVENT_HANDLER:`false`}
+    webhook-url: ${SLACK_WEBHOOK_URL}
 ---
 admin-auth:
   username: ${ADMIN_USER}

diff --git a/src/test/kotlin/com/kuvaszuptime/kuvasz/config/SMTPMailerConfigTest.kt b/src/test/kotlin/com/kuvaszuptime/kuvasz/config/SMTPMailerConfigTest.kt
@@ -9,7 +9,7 @@ import io.micronaut.context.env.PropertySource
 import io.micronaut.context.exceptions.BeanInstantiationException
 
 class SMTPMailerConfigTest : BehaviorSpec({
-    given("an SMTPMailerConfigTest bean") {
+    given("an SMTPMailerConfig bean") {
         `when`("the SMTP host does not exists") {
             val properties = PropertySource.of(
                 "test",