Cleanup, added logs

Author: pierre-leonard

build.gradle

@@ -26,11 +26,10 @@ jar {
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     testCompile group: 'junit', name: 'junit', version: '4.12'
-    implementation 'com.squareup.okhttp3:okhttp:4.7.2'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
-    implementation "com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8"
     implementation 'com.microsoft.sqlserver:mssql-jdbc:8.2.2.jre8'
     implementation 'com.typesafe:config:1.3.3'
+    implementation "io.github.microutils:kotlin-logging:1.6.22"
 }
 
 compileKotlin {

src/main/kotlin/fi/hsl/transitdata/dbmonitor/Main.kt

@@ -1,15 +1,31 @@
 package fi.hsl.transitdata.dbmonitor
 
 import fi.hsl.transitdata.dbmonitor.config.ConfigParser
+import mu.KotlinLogging
 import java.io.File
 import java.sql.Connection
 import java.sql.DriverManager
-import java.sql.SQLException
 import java.util.*
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
 
+private val log = KotlinLogging.logger {}
 fun main() {
+    startScheduler()
+}
+
+fun startScheduler(){
+    val scheduler = Executors.newScheduledThreadPool(1)
     val config = ConfigParser.createConfig()
-    MonitorService.start(config, createPubtransConnection())
+    scheduler.scheduleWithFixedDelay(Runnable {
+        try{
+            MonitorService.start(config, createPubtransConnection())
+            log.info("Db connection check complete")
+        }
+        catch(e : Exception){
+            log.error("Error while checking the databases:",e)
+        }
+    }, 0 ,5 , TimeUnit.MINUTES)
 }
 
 @Throws(Exception::class)

src/main/kotlin/fi/hsl/transitdata/dbmonitor/MonitorService.kt

@@ -1,28 +1,29 @@
 package fi.hsl.transitdata.dbmonitor
 
-import com.fasterxml.jackson.core.JsonFactory
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.module.kotlin.KotlinModule
 import com.typesafe.config.Config
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
+import mu.KotlinLogging
 import java.net.URL
 import java.sql.Connection
-import java.sql.DriverManager
 import java.sql.Statement
 
-
 object MonitorService{
-
-    private val f = JsonFactory()
-    private val mapper: ObjectMapper = ObjectMapper(f).registerModule(KotlinModule())
+    private val log = KotlinLogging.logger {}
 
     fun start(config : Config, connection : Connection)= runBlocking {
         try{
             connection.use {
                 config.getConfigList("databases").forEach {
-                        endpointToCheck ->  checkIfDbIfReachable(endpointToCheck.getString("dblabel"), endpointToCheck.getString("dbname"), it)
+                    endpointToCheck -> (
+                    try {
+                        checkIfDbIfReachable(endpointToCheck.getString("dblabel"), endpointToCheck.getString("dbname"), it)
+                    }
+                    catch(e : Exception){
+                        log.error ("Failed to connect to db", e)
+                        sendErrorMessageToSlack(e, config)
+                    })
                 }
             }
         }
@@ -31,31 +32,29 @@ object MonitorService{
         }
     }
 
-    private fun sendErrorMessageToSlack(e : Exception, config : Config){
+    private fun sendErrorMessageToSlack(e : Exception, config : Config, dblabel : String? = null){
 
         val url = URL(config.getString("slackbridge"))
         val headers : Map<String, String> = mapOf(
             Pair("Content-type","application/json")
         )
-
         NetworkHelper.getResponse(url, headers, config.getString("errormessage") + " " + e.message)
-        throw e
     }
 
     /**
      * Throws an exception if can't reach the db
      */
     private suspend fun checkIfDbIfReachable(dblabel : String, dbname : String, connection : Connection){
-        withContext(Dispatchers.IO) {
-            try {
-                val stmt: Statement = connection.createStatement()
-                stmt.execute("use [$dbname]")
-                stmt.close()
-                assert(connection.isValid(5000))
-            } catch (e: Exception) {
-                throw Exception("Connection to DB $dblabel failed")
-            }
-        }
+       withContext(Dispatchers.IO){
+           try {
+               val stmt: Statement = connection.createStatement()
+               stmt.execute("use [$dbname]")
+               stmt.close()
+               assert(connection.isValid(5000))
+           } catch (e: Exception) {
+               throw Exception("Connection to DB $dblabel failed", e)
+           }
+       }
     }
 }