♻️ logging everywhere (#138)

* ♻️ logging everywhere refactoring (flume like)

* ⬆️ version bump

* 🐛 escaping markdown in messages

* 🚨 barkers gonna bark

* ✅ fixing tests

* ⬆️ messages from the past, version bumpгора

* 💩🍺 barker barker widest mouth...

* 💩🍺 should work now clueless

* 💩🍺 update deprecated poops

* ⬆️ upgrade gradle

Co-authored-by: ShuffleZZZ <mihpihnaty@yandex.ru>

Author: Simon Naumov

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.2.2] - 18.04.2022
+
+### Fixed
+
+- Using logging everywhere
+- Escaping markdown in messages
+
 ## [1.2.1] - 04.04.2022
 
 ### Added
@@ -110,6 +117,7 @@
 -   Implicit party pulling
 -   Rude mode
 
+[1.2.2]: https://github.com/pool-party/pull-party-bot/compare/v1.2.1...v1.2.2
 [1.2.1]: https://github.com/pool-party/pull-party-bot/compare/v1.2.0...v1.2.1
 [1.2.0]: https://github.com/pool-party/pull-party-bot/compare/v1.1.0.2...v1.2.0
 [1.1.0.2]: https://github.com/pool-party/pull-party-bot/compare/v1.1.0.1...v1.1.0.2

Procfile

@@ -1 +1 @@
-web: java -jar build/libs/pull-party-bot-1.2.1.jar
+web: java -jar build/libs/pull-party-bot-1.2.2.jar

build.gradle.kts

@@ -2,46 +2,46 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     id("java")
-    id("org.jetbrains.kotlin.jvm") version "1.5.21"
-    kotlin("plugin.serialization") version "1.5.21"
+    id("org.jetbrains.kotlin.jvm") version "1.6.20"
+    kotlin("plugin.serialization") version "1.6.20"
 
-    id("org.flywaydb.flyway") version "7.12.0"
+    id("org.flywaydb.flyway") version "8.5.8"
 }
 
 group = "org.pool-party"
-version = "1.2.1"
+version = "1.2.2"
 
 repositories {
     maven("https://jitpack.io")
     mavenCentral()
 }
 
-val exposedVersion = "0.32.1"
-val testContainersVersion = "1.16.0"
-val jupyterVersion = "5.6.0"
-val kotlinVersion = "1.5.21"
+val exposedVersion = "0.38.1"
+val testContainersVersion = "1.17.1"
+val jupyterVersion = "5.8.2"
+val kotlinVersion = "1.6.20"
 
 dependencies {
     implementation("org.jetbrains.kotlin", "kotlin-stdlib-jdk8", kotlinVersion)
     implementation("org.jetbrains.kotlin", "kotlin-reflect", kotlinVersion)
-    implementation("org.jetbrains.kotlinx", "kotlinx-serialization-json", "1.2.2")
+    implementation("org.jetbrains.kotlinx", "kotlinx-serialization-json", "1.3.2")
     implementation("com.github.elbekD", "kt-telegram-bot", "1.4.1")
 
     implementation("org.jetbrains.exposed", "exposed-core", exposedVersion)
     implementation("org.jetbrains.exposed", "exposed-dao", exposedVersion)
     implementation("org.jetbrains.exposed", "exposed-jdbc", exposedVersion)
     implementation("org.jetbrains.exposed", "exposed-jodatime", exposedVersion)
 
-    implementation("org.flywaydb", "flyway-core", "7.12.0")
+    implementation("org.flywaydb", "flyway-core", "8.5.8")
 
     implementation("com.natpryce", "konfig", "1.6.10.0")
 
-    implementation("org.slf4j", "slf4j-simple", "2.0.0-alpha2")
-    implementation("io.github.microutils", "kotlin-logging", "2.0.10")
+    implementation("org.slf4j", "slf4j-simple", "2.0.0-alpha7")
+    implementation("io.github.microutils", "kotlin-logging", "2.1.21")
 
     implementation("info.debatty", "java-string-similarity", "2.0.0")
 
-    runtimeOnly("org.postgresql", "postgresql", "42.2.23")
+    runtimeOnly("org.postgresql", "postgresql", "42.3.4")
 
     testImplementation("org.jetbrains.kotlin", "kotlin-test-junit5", kotlinVersion)
     testImplementation("org.junit.jupiter", "junit-jupiter-api", jupyterVersion)
@@ -73,6 +73,6 @@ tasks.test {
 
 tasks.withType<KotlinCompile>().configureEach {
     kotlinOptions.jvmTarget = "1.8"
-    kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlinx.coroutines.DelicateCoroutinesApi"
-    kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlinx.serialization.ExperimentalSerializationApi"
+    kotlinOptions.freeCompilerArgs += "-opt-in=kotlinx.coroutines.DelicateCoroutinesApi"
+    kotlinOptions.freeCompilerArgs += "-opt-in=kotlinx.serialization.ExperimentalSerializationApi"
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/kotlin/com/github/pool_party/pull_party_bot/commands/Command.kt

@@ -77,14 +77,12 @@ abstract class CaseCommand(command: String, description: String, helpMessage: St
     protected fun Bot.sendCaseMessage(
         chatId: Long,
         message: String,
-        parseMode: String? = null,
         replyTo: Long? = null,
         markup: ReplyKeyboard? = null
     ) =
-        sendMessage(
+        sendMessageLogging(
             chatId,
             if (chatDao.getRude(chatId)) message.uppercase() else message,
-            parseMode,
             replyTo = replyTo,
             markup = markup
         )
@@ -104,15 +102,15 @@ fun Bot.validateAdministrator(user: User?, chat: Chat, sendMessage: Boolean = tr
     val chatId = chat.id
 
     if (user == null) {
-        sendMessage(chatId, ON_SENDER_FAIL, "Markdown")
+        sendMessageLogging(chatId, ON_SENDER_FAIL)
         return false
     }
 
     val chatType = chat.type
     if ((chatType == "group" || chatType == "supergroup") &&
         getChatAdministrators(chatId).join().all { it.user != user }
     ) {
-        if (sendMessage) sendMessage(chatId, ON_PERMISSION_DENY, "Markdown")
+        if (sendMessage) sendMessageLogging(chatId, ON_PERMISSION_DENY)
         return false
     }
     return true

src/main/kotlin/com/github/pool_party/pull_party_bot/commands/MessageUtils.kt

@@ -0,0 +1,44 @@
+package com.github.pool_party.pull_party_bot.commands
+
+import com.elbekD.bot.Bot
+import com.elbekD.bot.types.Message
+import com.elbekD.bot.types.ReplyKeyboard
+import mu.KotlinLogging
+import java.util.concurrent.CompletableFuture
+
+private val logger = KotlinLogging.logger { }
+
+fun <T> CompletableFuture<T>.logging(prefix: String = ""): CompletableFuture<T> = handleAsync { value, throwable ->
+    if (throwable != null) {
+        logger.error { "$prefix: ${throwable.message}:\n${throwable.stackTraceToString()}" }
+        throw throwable
+    }
+    value
+}
+
+private fun String.escape(symbols: String) = replace("[$symbols]".toRegex()) { "\\${it.groupValues[0]}" }
+
+private fun String.escapeSpecial() = escape("-!.<>\\(\\)")
+
+fun String.escapeMarkdown() = escape("-!.<>\\(\\)_*\\[\\]`")
+
+fun Bot.sendMessageLogging(
+    chatId: Long,
+    text: String,
+    markup: ReplyKeyboard? = null,
+    replyTo: Long? = null
+): CompletableFuture<out Message> {
+    logger.debug { "Sending '$text'" }
+    return sendMessage(chatId, text.escapeSpecial(), "MarkdownV2", replyTo = replyTo, markup = markup)
+        .logging("Failed to send message \"$text\"")
+}
+
+fun Bot.deleteMessageLogging(chatId: Long, messageId: Long): CompletableFuture<out Boolean> {
+    logger.debug { "Deleting message $chatId/$messageId" }
+    return deleteMessage(chatId, messageId).logging("Failed to delete message $chatId/$messageId")
+}
+
+fun Bot.answerCallbackQueryLogging(id: String, text: String? = null): CompletableFuture<out Boolean> {
+    logger.debug { "Answering callback query $id" }
+    return answerCallbackQuery(id, text).logging("Answering callback query $id")
+}

src/main/kotlin/com/github/pool_party/pull_party_bot/commands/handlers/AliasCommand.kt

@@ -9,39 +9,39 @@ import com.github.pool_party.pull_party_bot.commands.messages.ON_ALIAS_PARSE_FAI
 import com.github.pool_party.pull_party_bot.commands.messages.ON_CREATE_REQUEST_FAIL
 import com.github.pool_party.pull_party_bot.commands.messages.ON_PARTY_NAME_FAIL
 import com.github.pool_party.pull_party_bot.commands.messages.onAliasSuccess
+import com.github.pool_party.pull_party_bot.commands.sendMessageLogging
 import com.github.pool_party.pull_party_bot.database.dao.AliasCreationResult
 import com.github.pool_party.pull_party_bot.database.dao.ChatDao
 import com.github.pool_party.pull_party_bot.database.dao.PartyDao
 
 class AliasCommand(
     private val partyDao: PartyDao,
     chatDao: ChatDao,
-) : CaseCommand("alias", "create a party alias", HELP_ALIAS, chatDao) {
+) : CaseCommand("alias", "create a new party with the same users", HELP_ALIAS, chatDao) {
 
     override suspend fun Bot.action(message: Message, args: String?) {
         val parsedArgs = parseArgs(args)
         val chatId = message.chat.id
 
         if (parsedArgs.isNullOrEmpty() || parsedArgs.size != 2) {
-            sendMessage(chatId, ON_ALIAS_PARSE_FAIL, "Markdown")
+            sendMessageLogging(chatId, ON_ALIAS_PARSE_FAIL)
             return
         }
 
         val (aliasName, partyName) = parsedArgs
 
         if (!validatePartyName(aliasName)) {
-            sendMessage(chatId, ON_PARTY_NAME_FAIL, "Markdown")
+            sendMessageLogging(chatId, ON_PARTY_NAME_FAIL)
             return
         }
 
-        sendMessage(
+        sendMessageLogging(
             chatId,
             when (partyDao.createAlias(chatId, aliasName, partyName)) {
                 AliasCreationResult.SUCCESS -> onAliasSuccess(aliasName)
                 AliasCreationResult.NAME_TAKEN -> ON_CREATE_REQUEST_FAIL
                 AliasCreationResult.NO_PARTY -> ON_ALIAS_FAIL
             },
-            "Markdown"
         )
     }
 }

src/main/kotlin/com/github/pool_party/pull_party_bot/commands/handlers/ChangePartyCommands.kt

@@ -20,22 +20,37 @@ import com.github.pool_party.pull_party_bot.commands.messages.onAddSuccess
 import com.github.pool_party.pull_party_bot.commands.messages.onChangeSuccess
 import com.github.pool_party.pull_party_bot.commands.messages.onCreateSuccess
 import com.github.pool_party.pull_party_bot.commands.messages.onDeleteSuccess
+import com.github.pool_party.pull_party_bot.commands.sendMessageLogging
 import com.github.pool_party.pull_party_bot.database.dao.ChatDao
 import com.github.pool_party.pull_party_bot.database.dao.PartyDao
 
 class CreateCommand(partyDao: PartyDao, chatDao: ChatDao) :
-    AbstractChangeCommand("create", "create new party", HELP_CREATE, PartyChangeStatus.CREATE, partyDao, chatDao)
+    AbstractChangeCommand(
+        "create",
+        "create new party with mentioned users",
+        HELP_CREATE,
+        PartyChangeStatus.CREATE,
+        partyDao,
+        chatDao
+    )
 
 class ChangeCommand(partyDao: PartyDao, chatDao: ChatDao) :
-    AbstractChangeCommand("change", "changing existing party", HELP_CHANGE, PartyChangeStatus.CHANGE, partyDao, chatDao)
+    AbstractChangeCommand(
+        "change",
+        "change an existing party",
+        HELP_CHANGE,
+        PartyChangeStatus.CHANGE,
+        partyDao,
+        chatDao
+    )
 
 class AddCommand(partyDao: PartyDao, chatDao: ChatDao) :
-    AbstractChangeCommand("add", "add people to a party", HELP_ADD, PartyChangeStatus.ADD, partyDao, chatDao)
+    AbstractChangeCommand("add", "add new users to the given party", HELP_ADD, PartyChangeStatus.ADD, partyDao, chatDao)
 
 class RemoveCommand(partyDao: PartyDao, chatDao: ChatDao) :
     AbstractChangeCommand(
         "remove",
-        "remove people from a party",
+        "remove given users from the provided party",
         HELP_REMOVE,
         PartyChangeStatus.REMOVE,
         partyDao,
@@ -59,19 +74,18 @@ abstract class AbstractChangeCommand(
         // TODO suggest alias instead of party, if possible
 
         if (parsedArgs.isNullOrEmpty() || parsedArgs.size < 2) {
-            sendMessage(
+            sendMessageLogging(
                 chatId,
                 if (status == PartyChangeStatus.CREATE) ON_CREATE_EMPTY
                 else ON_CHANGE_EMPTY,
-                "Markdown"
             )
             return
         }
 
         val partyName = parsedArgs[0].removePrefix("@")
 
         if (!validatePartyName(partyName)) {
-            sendMessage(chatId, ON_PARTY_NAME_FAIL, "Markdown")
+            sendMessageLogging(chatId, ON_PARTY_NAME_FAIL)
             return
         }
 
@@ -86,12 +100,12 @@ abstract class AbstractChangeCommand(
         users = users.map { "@$it" }
 
         if (status.changesFull && users.singleOrNull()?.removePrefix("@") == partyName) {
-            sendMessage(chatId, ON_SINGLETON_PARTY, "Markdown")
+            sendMessageLogging(chatId, ON_SINGLETON_PARTY)
             return
         }
 
         if (failedUsers.isNotEmpty()) {
-            sendMessage(chatId, ON_USERS_FAIL)
+            sendMessageLogging(chatId, ON_USERS_FAIL)
 
             if (users.isEmpty()) {
                 sendMessage(
@@ -109,7 +123,7 @@ abstract class AbstractChangeCommand(
             return
         }
 
-        sendMessage(chatId, status.onFailure, "Markdown")
+        sendMessageLogging(chatId, status.onFailure)
     }
 }
 

src/main/kotlin/com/github/pool_party/pull_party_bot/commands/handlers/DeleteCommands.kt

@@ -14,20 +14,21 @@ import com.github.pool_party.pull_party_bot.commands.messages.ON_DELETE_EMPTY
 import com.github.pool_party.pull_party_bot.commands.messages.onAliasDeleteSuccess
 import com.github.pool_party.pull_party_bot.commands.messages.onPartyDeleteSuggest
 import com.github.pool_party.pull_party_bot.commands.messages.onPartyDeleteUnchanged
+import com.github.pool_party.pull_party_bot.commands.sendMessageLogging
 import com.github.pool_party.pull_party_bot.database.dao.ChatDao
 import com.github.pool_party.pull_party_bot.database.dao.PartyDao
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 
 class DeleteCommand(private val partyDao: PartyDao, chatDao: ChatDao) :
-    AdministratorCommand("delete", "forget the parties as they have never happened", HELP_DELETE, chatDao) {
+    AdministratorCommand("delete", "delete the parties you provided", HELP_DELETE, chatDao) {
 
     override fun Bot.mainAction(message: Message, args: String?) {
         val parsedArgs = parseArgs(args)?.distinct()
         val chatId = message.chat.id
 
         if (parsedArgs.isNullOrEmpty()) {
-            sendMessage(chatId, ON_DELETE_EMPTY, "Markdown")
+            sendMessageLogging(chatId, ON_DELETE_EMPTY)
             return
         }
 
@@ -81,6 +82,6 @@ class ClearCommand(chatDao: ChatDao) :
     override fun Bot.mainAction(message: Message, args: String?) {
         val chatId = message.chat.id
         chatDao.clear(chatId)
-        sendMessage(chatId, ON_CLEAR_SUCCESS, "Markdown")
+        sendMessageLogging(chatId, ON_CLEAR_SUCCESS)
     }
 }

src/main/kotlin/com/github/pool_party/pull_party_bot/commands/handlers/FeedbackCommand.kt

@@ -7,6 +7,7 @@ import com.github.pool_party.pull_party_bot.commands.AbstractCommand
 import com.github.pool_party.pull_party_bot.commands.messages.HELP_FEEDBACK
 import com.github.pool_party.pull_party_bot.commands.messages.ON_FEEDBACK_SUCCESS
 import com.github.pool_party.pull_party_bot.commands.messages.onFeedback
+import com.github.pool_party.pull_party_bot.commands.sendMessageLogging
 
 class FeedbackCommand : AbstractCommand("feedback", "share your ideas and experience with developers", HELP_FEEDBACK) {
 
@@ -15,11 +16,11 @@ class FeedbackCommand : AbstractCommand("feedback", "share your ideas and experi
         val developChatId = Configuration.DEVELOP_CHAT_ID
         if (developChatId == 0L || parsedArgs.isNullOrBlank()) return
 
-        sendMessage(
+        sendMessageLogging(
             developChatId,
             onFeedback(message.from?.username, message.chat.title) + parsedArgs
         )
 
-        sendMessage(message.chat.id, ON_FEEDBACK_SUCCESS, replyTo = message.message_id)
+        sendMessageLogging(message.chat.id, ON_FEEDBACK_SUCCESS, replyTo = message.message_id)
     }
 }