Feat/error logging system

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/SurfCoreApi.kt

@@ -1,5 +1,6 @@
 package dev.slne.surf.core.api.common
 
+import dev.slne.surf.core.api.common.error.SurfCoreError
 import dev.slne.surf.core.api.common.event.SurfEvent
 import dev.slne.surf.core.api.common.player.SurfPlayer
 import dev.slne.surf.core.api.common.server.CommonSurfServer
@@ -39,6 +40,19 @@ interface SurfCoreApi {
     fun fireEvent(event: SurfEvent)
     fun subscribe(eventClass: KClass<out SurfEvent>, handler: (SurfEvent) -> Unit)
 
+    fun logError(playerUuid: UUID, code: String, message: String)
+    fun logError(playerUuid: UUID, message: String): String
+
+    suspend fun logErrorAwaiting(
+        playerUuid: UUID,
+        code: String,
+        message: String,
+        server: String
+    ): SurfCoreError
+
+    suspend fun logErrorAwaiting(playerUuid: UUID, message: String, server: String): SurfCoreError
+    fun generateCode(): String
+
     fun sendPlayer(player: SurfPlayer, server: CommonSurfServer)
 
     /**

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/error/SurfCoreError.kt

@@ -0,0 +1,12 @@
+package dev.slne.surf.core.api.common.error
+
+import java.time.OffsetDateTime
+import java.util.*
+
+data class SurfCoreError(
+    val playerUuid: UUID,
+    val code: String,
+    val message: String,
+    val server: String,
+    val timestamp: OffsetDateTime
+)

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/error/SurfCoreErrorFilter.kt

@@ -0,0 +1,18 @@
+package dev.slne.surf.core.api.common.error
+
+import java.time.OffsetDateTime
+import java.util.*
+
+data class SurfCoreErrorFilter(
+    val playerUuid: UUID? = null,
+    val code: String? = null,
+    val messageLike: String? = null,
+    val server: String? = null,
+    val timestampAfter: OffsetDateTime? = null,
+    val timestampBefore: OffsetDateTime? = null,
+    val limit: Int = 50
+) {
+    companion object {
+        fun empty() = SurfCoreErrorFilter()
+    }
+}

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/error/SurfCoreSystemError.kt

@@ -0,0 +1,25 @@
+package dev.slne.surf.core.api.common.error
+
+import java.time.OffsetDateTime
+import java.util.*
+
+data class SurfCoreSystemError(
+    val uuid: UUID,
+    val errorCode: String,
+    val errorMessage: String,
+    val stacktrace: String,
+    val location: String,
+    val server: String,
+    val firstOccurred: OffsetDateTime,
+    val lastOccurred: OffsetDateTime,
+    val occurrenceCount: Int
+) {
+    fun getLocationClassName(): String =
+        location
+            .substringBefore(':')
+            .substringBeforeLast('.')
+            .substringAfterLast('.')
+            .substringBefore('$')
+
+
+}

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/error/SurfCoreSystemErrorFilter.kt

@@ -0,0 +1,22 @@
+package dev.slne.surf.core.api.common.error
+
+import java.time.OffsetDateTime
+import java.util.*
+
+data class SurfCoreSystemErrorFilter(
+    val uuid: UUID? = null,
+    val errorCode: String? = null,
+    val messageLike: String? = null,
+    val locationLike: String? = null,
+    val server: String? = null,
+    val firstOccurredAfter: OffsetDateTime? = null,
+    val firstOccurredBefore: OffsetDateTime? = null,
+    val lastOccurredAfter: OffsetDateTime? = null,
+    val lastOccurredBefore: OffsetDateTime? = null,
+    val minOccurrenceCount: Int? = null,
+    val limit: Int = 50
+) {
+    companion object {
+        fun empty() = SurfCoreSystemErrorFilter()
+    }
+}

surf-core-backend/src/main/kotlin/dev/slne/surf/core/fallback/DatabaseLoaderImpl.kt

@@ -2,10 +2,7 @@ package dev.slne.surf.core.fallback
 
 import com.google.auto.service.AutoService
 import dev.slne.surf.core.core.common.database.DatabaseLoader
-import dev.slne.surf.core.fallback.table.SurfPlayerIpAddressHistoryTable
-import dev.slne.surf.core.fallback.table.SurfPlayerNameHistoryTable
-import dev.slne.surf.core.fallback.table.SurfPlayerTable
-import dev.slne.surf.core.fallback.table.SurfPlayerTexturesHistoryTable
+import dev.slne.surf.core.fallback.table.*
 import dev.slne.surf.database.DatabaseApi
 import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.r2dbc.SchemaUtils
 import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.r2dbc.transactions.suspendTransaction
@@ -23,7 +20,9 @@ class DatabaseLoaderImpl : DatabaseLoader, Services.Fallback {
                 SurfPlayerTable,
                 SurfPlayerNameHistoryTable,
                 SurfPlayerIpAddressHistoryTable,
-                SurfPlayerTexturesHistoryTable
+                SurfPlayerTexturesHistoryTable,
+                SurfCoreErrorLogsTable,
+                SurfCoreSystemErrorTable
             )
         }
     }

surf-core-backend/src/main/kotlin/dev/slne/surf/core/fallback/repository/SurfCoreErrorLoggingRepository.kt

@@ -0,0 +1,108 @@
+package dev.slne.surf.core.fallback.repository
+
+import dev.slne.surf.core.api.common.error.SurfCoreError
+import dev.slne.surf.core.api.common.error.SurfCoreErrorFilter
+import dev.slne.surf.core.fallback.table.SurfCoreErrorLogsTable
+import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.core.*
+import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.r2dbc.insert
+import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.r2dbc.selectAll
+import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.r2dbc.transactions.suspendTransaction
+import dev.slne.surf.surfapi.core.api.util.toObjectList
+import it.unimi.dsi.fastutil.objects.ObjectList
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.toList
+import java.time.OffsetDateTime
+import java.util.*
+
+val surfCoreErrorLoggingRepository = SurfCoreErrorLoggingRepository()
+
+class SurfCoreErrorLoggingRepository {
+    suspend fun logError(
+        playerUuid: UUID,
+        code: String,
+        message: String,
+        server: String,
+    ): SurfCoreError = suspendTransaction {
+        val timestamp = OffsetDateTime.now()
+        SurfCoreErrorLogsTable.insert {
+            it[SurfCoreErrorLogsTable.playerUuid] = playerUuid
+            it[SurfCoreErrorLogsTable.errorCode] = code
+            it[SurfCoreErrorLogsTable.errorMessage] = message
+            it[SurfCoreErrorLogsTable.server] = server
+            it[SurfCoreErrorLogsTable.timestamp] = timestamp
+        }
+
+        SurfCoreError(playerUuid, code, message, server, timestamp)
+    }
+
+    suspend fun getErrors(playerUuid: UUID): ObjectList<SurfCoreError> = suspendTransaction {
+        SurfCoreErrorLogsTable.selectAll().where(SurfCoreErrorLogsTable.playerUuid eq playerUuid)
+            .map {
+                SurfCoreError(
+                    playerUuid = it[SurfCoreErrorLogsTable.playerUuid],
+                    code = it[SurfCoreErrorLogsTable.errorCode],
+                    message = it[SurfCoreErrorLogsTable.errorMessage],
+                    server = it[SurfCoreErrorLogsTable.server],
+                    timestamp = it[SurfCoreErrorLogsTable.timestamp]
+                )
+            }.toList().toObjectList()
+    }
+
+    suspend fun getErrors(filter: SurfCoreErrorFilter): ObjectList<SurfCoreError> =
+        suspendTransaction {
+            var query = SurfCoreErrorLogsTable.selectAll()
+
+            var whereCondition: Op<Boolean>? =
+                filter.playerUuid?.let { SurfCoreErrorLogsTable.playerUuid eq it }
+
+            filter.code?.let {
+                whereCondition = whereCondition.andCondition(SurfCoreErrorLogsTable.errorCode eq it)
+            }
+
+            filter.messageLike?.let {
+                whereCondition =
+                    whereCondition.andCondition(SurfCoreErrorLogsTable.errorMessage like "%$it%")
+            }
+
+            filter.server?.let {
+                whereCondition = whereCondition.andCondition(SurfCoreErrorLogsTable.server eq it)
+            }
+
+            filter.timestampAfter?.let {
+                whereCondition =
+                    whereCondition.andCondition(SurfCoreErrorLogsTable.timestamp greaterEq it)
+            }
+
+            filter.timestampBefore?.let {
+                whereCondition =
+                    whereCondition.andCondition(SurfCoreErrorLogsTable.timestamp lessEq it)
+            }
+
+            whereCondition?.let { query = query.where(it) }
+
+            query
+                .limit(filter.limit)
+                .map {
+                    SurfCoreError(
+                        playerUuid = it[SurfCoreErrorLogsTable.playerUuid],
+                        code = it[SurfCoreErrorLogsTable.errorCode],
+                        message = it[SurfCoreErrorLogsTable.errorMessage],
+                        server = it[SurfCoreErrorLogsTable.server],
+                        timestamp = it[SurfCoreErrorLogsTable.timestamp]
+                    )
+                }.toList().toObjectList()
+        }
+
+    suspend fun getError(code: String): SurfCoreError? = suspendTransaction {
+        SurfCoreErrorLogsTable.selectAll().where(SurfCoreErrorLogsTable.errorCode eq code).map {
+            SurfCoreError(
+                playerUuid = it[SurfCoreErrorLogsTable.playerUuid],
+                code = it[SurfCoreErrorLogsTable.errorCode],
+                message = it[SurfCoreErrorLogsTable.errorMessage],
+                server = it[SurfCoreErrorLogsTable.server],
+                timestamp = it[SurfCoreErrorLogsTable.timestamp]
+            )
+        }.firstOrNull()
+    }
+}