feat: add tcpDebug option and tracing

Decodetalkers · Decodetalkers · commit 2ea49b19b3ba · 2025-01-19T12:20:54.000+09:00
this made me easier to debug the project

and fix some warning
diff --git a/server/build.gradle.kts b/server/build.gradle.kts
@@ -9,8 +9,9 @@ plugins {
     id("kotlin-language-server.kotlin-conventions")
 }
 
+val serverDebugPort = 4000
 val debugPort = 8000
-val debugArgs = "-agentlib:jdwp=transport=dt_socket,server=y,address=8000,suspend=n,quiet=y"
+val debugArgs = "-agentlib:jdwp=transport=dt_socket,server=y,address=$debugPort,suspend=n,quiet=y"
 
 val serverMainClassName = "org.javacs.kt.MainKt"
 val applicationName = "kotlin-language-server"
@@ -91,6 +92,7 @@ tasks.register<JavaExec>("debugRun") {
     standardInput = System.`in`
 
     jvmArgs(debugArgs)
+    args(listOf("--tcpServerPort", serverDebugPort, "--tcpDebug", "--tracingLog"))
     doLast { println("Using debug port $debugPort") }
 }
 
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt b/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt
@@ -23,17 +23,29 @@ import java.util.concurrent.CompletableFuture
 import java.util.concurrent.CompletableFuture.completedFuture
 
 class KotlinLanguageServer(
-    val config: Configuration = Configuration()
+    val config: Configuration = Configuration(),
+    private val tcpDebug: Boolean = false
 ) : LanguageServer, LanguageClientAware, Closeable {
-    val databaseService = DatabaseService()
+    private val databaseService = DatabaseService()
     val classPath = CompilerClassPath(config.compiler, config.scripts, config.codegen, databaseService)
 
     private val tempDirectory = TemporaryDirectory()
-    private val uriContentProvider = URIContentProvider(ClassContentProvider(config.externalSources, classPath, tempDirectory, CompositeSourceArchiveProvider(JdkSourceArchiveProvider(classPath), ClassPathSourceArchiveProvider(classPath))))
+    private val uriContentProvider = URIContentProvider(
+        ClassContentProvider(
+            config.externalSources,
+            classPath,
+            tempDirectory,
+            CompositeSourceArchiveProvider(
+                JdkSourceArchiveProvider(classPath),
+                ClassPathSourceArchiveProvider(classPath)
+            )
+        )
+    )
     val sourcePath = SourcePath(classPath, uriContentProvider, config.indexing, databaseService)
-    val sourceFiles = SourceFiles(sourcePath, uriContentProvider, config.scripts)
+    private val sourceFiles = SourceFiles(sourcePath, uriContentProvider, config.scripts)
 
-    private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider, classPath)
+    private val textDocuments =
+        KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider, classPath)
     private val workspaces = KotlinWorkspaceService(sourceFiles, sourcePath, classPath, textDocuments, config)
     private val protocolExtensions = KotlinProtocolExtensionService(uriContentProvider, classPath, sourcePath)
 
@@ -56,7 +68,9 @@ class KotlinLanguageServer(
 
     override fun connect(client: LanguageClient) {
         this.client = client
-        connectLoggingBackend()
+        if (!tcpDebug) {
+            connectLoggingBackend()
+        }
 
         workspaces.connect(client)
         textDocuments.connect(client)
@@ -87,7 +101,8 @@ class KotlinLanguageServer(
         serverCapabilities.documentSymbolProvider = Either.forLeft(true)
         serverCapabilities.workspaceSymbolProvider = Either.forLeft(true)
         serverCapabilities.referencesProvider = Either.forLeft(true)
-        serverCapabilities.semanticTokensProvider = SemanticTokensWithRegistrationOptions(semanticTokensLegend, true, true)
+        serverCapabilities.semanticTokensProvider =
+            SemanticTokensWithRegistrationOptions(semanticTokensLegend, true, true)
         serverCapabilities.codeActionProvider = Either.forLeft(true)
         serverCapabilities.documentFormattingProvider = Either.forLeft(true)
         serverCapabilities.documentRangeFormattingProvider = Either.forLeft(true)
@@ -98,13 +113,14 @@ class KotlinLanguageServer(
         databaseService.setup(storagePath)
 
         val clientCapabilities = params.capabilities
-        config.completion.snippets.enabled = clientCapabilities?.textDocument?.completion?.completionItem?.snippetSupport ?: false
+        config.completion.snippets.enabled =
+            clientCapabilities?.textDocument?.completion?.completionItem?.snippetSupport ?: false
 
-        if (clientCapabilities?.window?.workDoneProgress ?: false) {
+        if (clientCapabilities?.window?.workDoneProgress == true) {
             progressFactory = LanguageClientProgress.Factory(client)
         }
 
-        if (clientCapabilities?.textDocument?.rename?.prepareSupport ?: false) {
+        if (clientCapabilities?.textDocument?.rename?.prepareSupport == true) {
             serverCapabilities.renameProvider = Either.forRight(RenameOptions(false))
         }
 
@@ -176,6 +192,6 @@ class KotlinLanguageServer(
     // Fixed in https://github.com/eclipse/lsp4j/commit/04b0c6112f0a94140e22b8b15bb5a90d5a0ed851
     // Causes issue in lsp 0.15
     override fun getNotebookDocumentService(): NotebookDocumentService? {
-		return null;
-	}
+        return null;
+    }
 }
diff --git a/server/src/main/kotlin/org/javacs/kt/Main.kt b/server/src/main/kotlin/org/javacs/kt/Main.kt
@@ -7,21 +7,27 @@ import org.eclipse.lsp4j.launch.LSPLauncher
 import org.javacs.kt.util.ExitingInputStream
 import org.javacs.kt.util.tcpStartServer
 import org.javacs.kt.util.tcpConnectToClient
-
 class Args {
     /*
      * The language server can currently be launched in three modes:
      *  - Stdio, in which case no argument should be specified (used by default)
      *  - TCP Server, in which case the client has to connect to the specified tcpServerPort (used by the Docker image)
      *  - TCP Client, in which case the server will connect to the specified tcpClientPort/tcpClientHost (optionally used by VSCode)
      */
-
     @Parameter(names = ["--tcpServerPort", "-sp"])
     var tcpServerPort: Int? = null
+
     @Parameter(names = ["--tcpClientPort", "-p"])
     var tcpClientPort: Int? = null
+
     @Parameter(names = ["--tcpClientHost", "-h"])
     var tcpClientHost: String = "localhost"
+
+    @Parameter(names = ["--tcpDebug"])
+    var tcpDebug: Boolean = false
+
+    @Parameter(names = ["--tracingLog"])
+    var tracingLog: Boolean = false
 }
 
 fun main(argv: Array<String>) {
@@ -39,7 +45,10 @@ fun main(argv: Array<String>) {
         tcpStartServer(it)
     } ?: Pair(System.`in`, System.out)
 
-    val server = KotlinLanguageServer()
+    if (args.tracingLog) {
+        LOG.setTracing()
+    }
+    val server = KotlinLanguageServer(tcpDebug = args.tcpDebug)
     val threads = Executors.newSingleThreadExecutor { Thread(it, "client") }
     val launcher = LSPLauncher.createServerLauncher(server, ExitingInputStream(inStream), outStream, threads) { it }
 
diff --git a/shared/src/main/kotlin/org/javacs/kt/Logger.kt b/shared/src/main/kotlin/org/javacs/kt/Logger.kt
@@ -12,7 +12,7 @@ import org.javacs.kt.util.DelegatePrintStream
 
 val LOG = Logger()
 
-private class JULRedirector(private val downstream: Logger): Handler() {
+private class JULRedirector(private val downstream: Logger) : Handler() {
     override fun publish(record: LogRecord) {
         when (record.level) {
             Level.SEVERE -> downstream.error(record.message)
@@ -43,10 +43,17 @@ enum class LogLevel(val value: Int) {
 
 class LogMessage(
     val level: LogLevel,
-    val message: String
+    val message: String,
+    private val funName: String? = null,
 ) {
     val formatted: String
-        get() = "[$level] $message"
+        get() {
+            return if (funName != null) {
+                "[$level] $funName $message"
+            } else {
+                "[$level] $message"
+            }
+        }
 }
 
 class Logger {
@@ -58,10 +65,11 @@ class Logger {
     val outStream = DelegatePrintStream { log(LogMessage(LogLevel.INFO, it.trimEnd())) }
 
     private val newline = System.lineSeparator()
-    val logTime = false
+    private val logTime = false
     var level = LogLevel.INFO
+    var tracingLog = false;
 
-    fun logError(msg: LogMessage) {
+    private fun logError(msg: LogMessage) {
         if (errBackend == null) {
             errQueue.offer(msg)
         } else {
@@ -78,14 +86,24 @@ class Logger {
     }
 
     private fun logWithPlaceholdersAt(msgLevel: LogLevel, msg: String, placeholders: Array<out Any?>) {
+        val stackTraceElement = if (tracingLog) {
+            Throwable("Capturing stack trace for logging").stackTrace.firstOrNull { it.className != this::class.java.name }
+        } else {
+            null
+        }
         if (level.value <= msgLevel.value) {
-            log(LogMessage(msgLevel, format(insertPlaceholders(msg, placeholders))))
+            log(LogMessage(msgLevel, format(insertPlaceholders(msg, placeholders)), stackTraceElement?.className))
         }
     }
 
-    inline fun logWithLambdaAt(msgLevel: LogLevel, msg: () -> String) {
+    inline fun logWithLambdaAt(msgLevel: LogLevel, crossinline msg: () -> String) {
+        val stackTraceElement = if (tracingLog) {
+            Throwable("Capturing stack trace for logging").stackTrace.firstOrNull { it.className != this::class.java.name }
+        } else {
+            null
+        }
         if (level.value <= msgLevel.value) {
-            log(LogMessage(msgLevel, msg()))
+            log(LogMessage(msgLevel, msg(), stackTraceElement?.className))
         }
     }
 
@@ -103,22 +121,26 @@ class Logger {
 
     fun trace(msg: String, vararg placeholders: Any?) = logWithPlaceholdersAt(LogLevel.TRACE, msg, placeholders)
 
-    fun deepTrace(msg: String, vararg placeholders: Any?) = logWithPlaceholdersAt(LogLevel.DEEP_TRACE, msg, placeholders)
+    fun deepTrace(msg: String, vararg placeholders: Any?) =
+        logWithPlaceholdersAt(LogLevel.DEEP_TRACE, msg, placeholders)
 
     // Convenience logging methods using inlined lambdas
 
-    inline fun error(msg: () -> String) = logWithLambdaAt(LogLevel.ERROR, msg)
+    inline fun error(crossinline msg: () -> String) = logWithLambdaAt(LogLevel.ERROR, msg)
 
-    inline fun warn(msg: () -> String) = logWithLambdaAt(LogLevel.WARN, msg)
+    inline fun warn(crossinline msg: () -> String) = logWithLambdaAt(LogLevel.WARN, msg)
 
-    inline fun info(msg: () -> String) = logWithLambdaAt(LogLevel.INFO, msg)
+    inline fun info(crossinline msg: () -> String) = logWithLambdaAt(LogLevel.INFO, msg)
 
-    inline fun debug(msg: () -> String) = logWithLambdaAt(LogLevel.DEBUG, msg)
+    inline fun debug(crossinline msg: () -> String) = logWithLambdaAt(LogLevel.DEBUG, msg)
 
-    inline fun trace(msg: () -> String) = logWithLambdaAt(LogLevel.TRACE, msg)
+    inline fun trace(crossinline msg: () -> String) = logWithLambdaAt(LogLevel.TRACE, msg)
 
-    inline fun deepTrace(msg: () -> String) = logWithLambdaAt(LogLevel.DEEP_TRACE, msg)
+    inline fun deepTrace(crossinline msg: () -> String) = logWithLambdaAt(LogLevel.DEEP_TRACE, msg)
 
+    fun setTracing() {
+        tracingLog = true
+    }
     fun connectJULFrontend() {
         val rootLogger = java.util.logging.Logger.getLogger("")
         rootLogger.addHandler(JULRedirector(this))
@@ -182,9 +204,9 @@ class Logger {
     }
 
     private fun shortenOrPad(str: String, length: Int): String =
-            if (str.length <= length) {
-                str.padEnd(length, ' ')
-            } else {
-                ".." + str.substring(str.length - length + 2)
-            }
+        if (str.length <= length) {
+            str.padEnd(length, ' ')
+        } else {
+            ".." + str.substring(str.length - length + 2)
+        }
 }
diff --git a/shared/src/main/kotlin/org/javacs/kt/util/DelegatePrintStream.kt b/shared/src/main/kotlin/org/javacs/kt/util/DelegatePrintStream.kt
@@ -4,67 +4,67 @@ import java.io.ByteArrayOutputStream
 import java.io.PrintStream
 import java.util.function.Consumer
 
-class DelegatePrintStream(private val delegate: (String) -> Unit): PrintStream(ByteArrayOutputStream(0)) {
-	private val newLine = System.lineSeparator()
+class DelegatePrintStream(private val delegate: (String) -> Unit) : PrintStream(ByteArrayOutputStream(0)) {
+    private val newLine = System.lineSeparator()
 
-	override fun write(c: Int) = delegate((c.toChar()).toString())
+    override fun write(c: Int) = delegate((c.toChar()).toString())
 
-	override fun write(buf: ByteArray, off: Int, len: Int) {
-		if (len > 0 && buf.size > 0) {
-			delegate(String(buf, off, len))
-		}
-	}
+    override fun write(buf: ByteArray, off: Int, len: Int) {
+        if (len > 0 && buf.isNotEmpty()) {
+            delegate(String(buf, off, len))
+        }
+    }
 
-	override fun append(csq: CharSequence): PrintStream {
-		delegate(csq.toString())
-		return this
-	}
+    override fun append(csq: CharSequence): PrintStream {
+        delegate(csq.toString())
+        return this
+    }
 
-	override fun append(csq: CharSequence, start: Int, end: Int): PrintStream {
-		delegate(csq.subSequence(start, end).toString())
-		return this
-	}
+    override fun append(csq: CharSequence, start: Int, end: Int): PrintStream {
+        delegate(csq.subSequence(start, end).toString())
+        return this
+    }
 
-	override fun append(c:Char): PrintStream {
-		delegate((c).toString())
-		return this
-	}
+    override fun append(c: Char): PrintStream {
+        delegate((c).toString())
+        return this
+    }
 
-	override fun print(x: Boolean) = delegate(x.toString())
+    override fun print(x: Boolean) = delegate(x.toString())
 
-	override fun print(x: Char) = delegate(x.toString())
+    override fun print(x: Char) = delegate(x.toString())
 
-	override fun print(x: Int) = delegate(x.toString())
+    override fun print(x: Int) = delegate(x.toString())
 
-	override fun print(x: Long) = delegate(x.toString())
+    override fun print(x: Long) = delegate(x.toString())
 
-	override fun print(x: Float) = delegate(x.toString())
+    override fun print(x: Float) = delegate(x.toString())
 
-	override fun print(x: Double) = delegate(x.toString())
+    override fun print(x: Double) = delegate(x.toString())
 
-	override fun print(s: CharArray) = delegate(String(s))
+    override fun print(s: CharArray) = delegate(String(s))
 
-	override fun print(s: String) = delegate(s)
+    override fun print(s: String?) = delegate(s ?: "null")
 
-	override fun print(obj: Any) = delegate(obj.toString())
+    override fun print(obj: Any?) = delegate(obj.toString())
 
-	override fun println() = delegate(newLine)
+    override fun println() = delegate(newLine)
 
-	override fun println(x: Boolean) = delegate(x.toString() + newLine)
+    override fun println(x: Boolean) = delegate(x.toString() + newLine)
 
-	override fun println(x: Char) = delegate(x.toString() + newLine)
+    override fun println(x: Char) = delegate(x.toString() + newLine)
 
-	override fun println(x: Int) = delegate(x.toString() + newLine)
+    override fun println(x: Int) = delegate(x.toString() + newLine)
 
-	override fun println(x: Long) = delegate(x.toString() + newLine)
+    override fun println(x: Long) = delegate(x.toString() + newLine)
 
-	override fun println(x: Float) = delegate(x.toString() + newLine)
+    override fun println(x: Float) = delegate(x.toString() + newLine)
 
-	override fun println(x: Double) = delegate(x.toString() + newLine)
+    override fun println(x: Double) = delegate(x.toString() + newLine)
 
-	override fun println(x: CharArray) = delegate(String(x) + newLine)
+    override fun println(x: CharArray) = delegate(String(x) + newLine)
 
-	override fun println(x: String) = delegate(x + newLine)
+    override fun println(x: String?) = delegate((x ?: "null") + newLine)
 
-	override fun println(x: Any) = delegate(x.toString() + newLine)
+    override fun println(x: Any?) = delegate(x.toString() + newLine)
 }

Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,9 @@ plugins {`
`9`	`9`	`id("kotlin-language-server.kotlin-conventions")`
`10`	`10`	`}`
`11`	`11`
	`12`	`+val serverDebugPort = 4000`
`12`	`13`	`val debugPort = 8000`
`13`		`-val debugArgs = "-agentlib:jdwp=transport=dt_socket,server=y,address=8000,suspend=n,quiet=y"`
	`14`	`+val debugArgs = "-agentlib:jdwp=transport=dt_socket,server=y,address=$debugPort,suspend=n,quiet=y"`
`14`	`15`
`15`	`16`	`val serverMainClassName = "org.javacs.kt.MainKt"`
`16`	`17`	`val applicationName = "kotlin-language-server"`
`@@ -91,6 +92,7 @@ tasks.register<JavaExec>("debugRun") {`
`91`	`92`	standardInput = System.`in`
`92`	`93`
`93`	`94`	`jvmArgs(debugArgs)`
	`95`	`+ args(listOf("--tcpServerPort", serverDebugPort, "--tcpDebug", "--tracingLog"))`
`94`	`96`	`doLast { println("Using debug port $debugPort") }`
`95`	`97`	`}`
`96`	`98`