Kotlinスクリプトで実現するカスタムログフォーマッタ作成ガイド

  kotlinc -version

dependencies {
    implementation("org.slf4j:slf4j-api:1.7.36")
    implementation("ch.qos.logback:logback-classic:1.2.11")
}

// sample.kts
println("Kotlin Script Environment is Ready!")

kotlinc -script sample.kts

[2024-12-17 10:00:00] INFO - Application started successfully

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

// ログレベルの定義
enum class LogLevel {
    INFO, WARN, ERROR
}

// カスタムログフォーマッタクラス
class CustomLogFormatter {

    private val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")

    // フォーマット関数
    fun format(level: LogLevel, message: String): String {
        val timestamp = LocalDateTime.now().format(dateTimeFormatter)
        return "[$timestamp] $level - $message"
    }
}

// ログフォーマッタのテスト
val formatter = CustomLogFormatter()
println(formatter.format(LogLevel.INFO, "Application started successfully"))
println(formatter.format(LogLevel.WARN, "Disk space is running low"))
println(formatter.format(LogLevel.ERROR, "Failed to connect to the database"))

[2024-12-17 10:00:00] INFO - Application started successfully  
[2024-12-17 10:01:00] WARN - Disk space is running low  
[2024-12-17 10:02:00] ERROR - Failed to connect to the database  

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

// ログレベルの定義
enum class LogLevel {
    INFO, WARN, ERROR, DEBUG
}

// 拡張ログフォーマッタクラス
class AdvancedLogFormatter {

    private val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")

    // フォーマット関数
    fun format(level: LogLevel, message: String): String {
        val timestamp = LocalDateTime.now().format(dateTimeFormatter)
        val threadName = Thread.currentThread().name
        val callerInfo = getCallerInfo()
        return "[$timestamp] [$threadName] [$callerInfo] $level - $message"
    }

    // 呼び出し元情報の取得
    private fun getCallerInfo(): String {
        val stackTrace = Thread.currentThread().stackTrace
        if (stackTrace.size > 3) {
            val element = stackTrace[3]
            return "${element.className}.${element.methodName}:${element.lineNumber}"
        }
        return "Unknown"
    }
}

// ログフォーマッタのテスト
val formatter = AdvancedLogFormatter()
println(formatter.format(LogLevel.DEBUG, "Initializing system..."))
println(formatter.format(LogLevel.INFO, "Application is running."))
println(formatter.format(LogLevel.ERROR, "Null pointer exception occurred."))

[2024-12-17 10:15:30.123] [main] [AdvancedLogFormatter.main:23] DEBUG - Initializing system...  
[2024-12-17 10:15:31.456] [main] [AdvancedLogFormatter.main:24] INFO - Application is running.  
[2024-12-17 10:15:32.789] [main] [AdvancedLogFormatter.main:25] ERROR - Null pointer exception occurred.  

import java.io.File
import java.io.FileWriter
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

// 拡張ログフォーマッタクラス
class FileLogFormatter(private val logFilePath: String) {

    private val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")

    // ログファイルの初期化
    init {
        File(logFilePath).apply {
            if (!exists()) createNewFile()
        }
    }

    // フォーマット関数
    fun logToFile(level: LogLevel, message: String) {
        val timestamp = LocalDateTime.now().format(dateTimeFormatter)
        val logMessage = "[$timestamp] $level - $message"
        writeToFile(logMessage)
    }

    // ファイルへの書き込み
    private fun writeToFile(logMessage: String) {
        FileWriter(logFilePath, true).use { writer ->
            writer.write("$logMessage\n")
        }
    }
}

// ログファイル出力のテスト
val fileFormatter = FileLogFormatter("application.log")
fileFormatter.logToFile(LogLevel.INFO, "Application started.")
fileFormatter.logToFile(LogLevel.WARN, "Low disk space.")
fileFormatter.logToFile(LogLevel.ERROR, "Unhandled exception occurred.")

[2024-12-17 10:20:30.123] INFO - Application started.  
[2024-12-17 10:21:30.456] WARN - Low disk space.  
[2024-12-17 10:22:30.789] ERROR - Unhandled exception occurred.  

import java.net.HttpURLConnection
import java.net.URL

class ExternalLogFormatter(private val endpoint: String) {

    // ログ送信関数
    fun sendLog(level: LogLevel, message: String) {
        val logData = "{ \"level\": \"$level\", \"message\": \"$message\" }"
        postLog(logData)
    }

    // HTTP POSTリクエスト
    private fun postLog(logData: String) {
        val url = URL(endpoint)
        val connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.doOutput = true
        connection.setRequestProperty("Content-Type", "application/json")
        connection.outputStream.use { os ->
            os.write(logData.toByteArray())
        }
        connection.responseCode // レスポンスを確認（必要なら処理を追加）
    }
}

// 外部ツール連携のテスト
val externalFormatter = ExternalLogFormatter("http://example.com/logs")
externalFormatter.sendLog(LogLevel.INFO, "Application started.")
externalFormatter.sendLog(LogLevel.ERROR, "Critical system error.")

val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")

val responseCode = connection.responseCode
if (responseCode != HttpURLConnection.HTTP_OK) {
    println("Failed to send log. HTTP status: $responseCode")
}

import kotlinx.coroutines.*

fun logAsync(level: LogLevel, message: String) = GlobalScope.launch {
    val logFormatter = AdvancedLogFormatter()
    println(logFormatter.format(level, message))
}

println("Formatting log: Level=$level, Message=$message")

@Test
fun testLogFormat() {
    val formatter = CustomLogFormatter()
    val log = formatter.format(LogLevel.INFO, "Test message")
    assertTrue(log.contains("INFO"))
    assertTrue(log.contains("Test message"))
}

import io.ktor.application.*
import io.ktor.response.*
import io.ktor.request.*
import io.ktor.routing.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

// ログフォーマッタクラス
class KtorLogFormatter {

    private val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")

    // フォーマット関数
    fun format(request: ApplicationRequest, responseStatus: Int): String {
        val timestamp = LocalDateTime.now().format(dateTimeFormatter)
        val method = request.httpMethod.value
        val uri = request.uri
        val clientIP = request.origin.remoteHost
        return "[$timestamp] $method $uri (Client: $clientIP) - Status: $responseStatus"
    }
}

// アプリケーションエントリーポイント
fun main() {
    val logFormatter = KtorLogFormatter()

    embeddedServer(Netty, port = 8080) {
        routing {
            get("/") {
                call.respondText("Hello, World!")
                println(logFormatter.format(call.request, 200))
            }
            get("/error") {
                call.respondText("Error occurred", status = io.ktor.http.HttpStatusCode.InternalServerError)
                println(logFormatter.format(call.request, 500))
            }
        }
    }.start(wait = true)
}

[2024-12-17 10:30:00.123] GET / (Client: 127.0.0.1) - Status: 200  
[2024-12-17 10:30:10.456] GET /error (Client: 127.0.0.1) - Status: 500