add color to build output && push originId into server responses

bazelrunner/src/main/java/org/jetbrains/bsp/bazel/bazelrunner/BazelProcess.kt

@@ -1,32 +1,33 @@
 package org.jetbrains.bsp.bazel.bazelrunner
 
+import java.time.Duration
 import org.apache.logging.log4j.LogManager
 import org.jetbrains.bsp.bazel.bazelrunner.outputs.AsyncOutputProcessor
 import org.jetbrains.bsp.bazel.commons.Format
 import org.jetbrains.bsp.bazel.commons.Stopwatch
 import org.jetbrains.bsp.bazel.logger.BspClientLogger
-import java.time.Duration
 
 class BazelProcess internal constructor(
     private val process: Process,
-    private val logger: BspClientLogger
+    private val logger: BspClientLogger,
+    private val originId: String?
 ) {
 
-  fun waitAndGetResult(): BazelProcessResult {
-    val outputProcessor = AsyncOutputProcessor(process, logger::message, LOGGER::info)
-    val stopwatch = Stopwatch.start()
+    fun waitAndGetResult(): BazelProcessResult {
+        val outputProcessor = AsyncOutputProcessor(process, { logger.message(it, originId) }, LOGGER::info)
+        val stopwatch = Stopwatch.start()
 
-    val exitCode = outputProcessor.waitForExit()
-    val duration = stopwatch.stop()
-    logCompletion(exitCode, duration)
-    return BazelProcessResult(outputProcessor.stdoutCollector, outputProcessor.stderrCollector, exitCode)
-  }
+        val exitCode = outputProcessor.waitForExit()
+        val duration = stopwatch.stop()
+        logCompletion(exitCode, duration)
+        return BazelProcessResult(outputProcessor.stdoutCollector, outputProcessor.stderrCollector, exitCode)
+    }
 
-  private fun logCompletion(exitCode: Int, duration: Duration) {
-    logger.message("Command completed in %s (exit code %d)", Format.duration(duration), exitCode)
-  }
+    private fun logCompletion(exitCode: Int, duration: Duration) {
+        logger.message("Command completed in %s (exit code %d)".format(Format.duration(duration), exitCode), originId)
+    }
 
-  companion object {
-    private val LOGGER = LogManager.getLogger(BazelProcess::class.java)
-  }
+    companion object {
+        private val LOGGER = LogManager.getLogger(BazelProcess::class.java)
+    }
 }

bazelrunner/src/main/java/org/jetbrains/bsp/bazel/bazelrunner/BazelRunner.kt

@@ -1,61 +1,71 @@
 package org.jetbrains.bsp.bazel.bazelrunner
 
+import java.nio.file.Path
 import org.apache.logging.log4j.LogManager
 import org.jetbrains.bsp.bazel.logger.BspClientLogger
 import org.jetbrains.bsp.bazel.workspacecontext.WorkspaceContext
 import org.jetbrains.bsp.bazel.workspacecontext.WorkspaceContextProvider
-import java.nio.file.Path
 
 class BazelRunner private constructor(
     private val workspaceContextProvider: WorkspaceContextProvider,
     private val bspClientLogger: BspClientLogger,
     val workspaceRoot: Path?,
 ) {
 
-  companion object {
-    private val LOGGER = LogManager.getLogger(BazelRunner::class.java)
+    companion object {
+        private val LOGGER = LogManager.getLogger(BazelRunner::class.java)
 
-    @JvmStatic
-    fun of(
-        workspaceContextProvider: WorkspaceContextProvider,
-        bspClientLogger: BspClientLogger,
-        workspaceRoot: Path?,
-    ): BazelRunner {
-      return BazelRunner(workspaceContextProvider, bspClientLogger, workspaceRoot)
+        @JvmStatic
+        fun of(
+            workspaceContextProvider: WorkspaceContextProvider,
+            bspClientLogger: BspClientLogger,
+            workspaceRoot: Path?,
+        ): BazelRunner {
+            return BazelRunner(workspaceContextProvider, bspClientLogger, workspaceRoot)
+        }
     }
-  }
 
-  private var besBackendPort: Int? = null
+    private var besBackendPort: Int? = null
 
-  fun commandBuilder(): BazelRunnerCommandBuilder = BazelRunnerCommandBuilder(this)
+    fun commandBuilder(): BazelRunnerCommandBuilder = BazelRunnerCommandBuilder(this)
 
-  fun runBazelCommandBes(command: String, flags: List<String>, arguments: List<String>): BazelProcess {
-    fun besFlags() = listOf("--bes_backend=grpc://localhost:${besBackendPort!!}")
+    fun runBazelCommandBes(
+        command: String,
+        flags: List<String>,
+        arguments: List<String>,
+        originId: String?
+    ): BazelProcess {
+        fun besFlags() = listOf("--bes_backend=grpc://localhost:${besBackendPort!!}")
 
-    return runBazelCommand(command, flags = besFlags() + flags, arguments)
-  }
+        return runBazelCommand(command, flags = besFlags() + flags, arguments, originId)
+    }
 
-  fun runBazelCommand(command: String, flags: List<String>, arguments: List<String>): BazelProcess {
-    val workspaceContext = workspaceContextProvider.currentWorkspaceContext()
+    fun runBazelCommand(
+        command: String,
+        flags: List<String>,
+        arguments: List<String>,
+        originId: String?
+    ): BazelProcess {
+        val workspaceContext = workspaceContextProvider.currentWorkspaceContext()
 
-    val processArgs = listOf(bazel(workspaceContext), command) + buildFlags(workspaceContext) + flags + arguments
-    logInvocation(processArgs)
-    val processBuilder = ProcessBuilder(processArgs)
-    workspaceRoot?.let { processBuilder.directory(it.toFile()) }
-    val process = processBuilder.start()
-    return BazelProcess(process, bspClientLogger)
-  }
+        val processArgs = listOf(bazel(workspaceContext), command) + buildFlags(workspaceContext) + flags + arguments
+        logInvocation(processArgs, originId)
+        val processBuilder = ProcessBuilder(processArgs)
+        workspaceRoot?.let { processBuilder.directory(it.toFile()) }
+        val process = processBuilder.start()
+        return BazelProcess(process, bspClientLogger, originId)
+    }
 
-  private fun logInvocation(processArgs: List<String>) {
-    "Invoking: ${processArgs.joinToString(" ")}"
-        .also { LOGGER.info(it) }
-        .also { bspClientLogger.message(it) }
-  }
+    private fun logInvocation(processArgs: List<String>, originId: String?) {
+        "Invoking: ${processArgs.joinToString(" ")}"
+            .also { LOGGER.info(it) }
+            .also { bspClientLogger.message(it, originId) }
+    }
 
-  private fun bazel(workspaceContext: WorkspaceContext): String = workspaceContext.bazelPath.value.toString()
-  private fun buildFlags(workspaceContext: WorkspaceContext): List<String> = workspaceContext.buildFlags.values
+    private fun bazel(workspaceContext: WorkspaceContext): String = workspaceContext.bazelPath.value.toString()
+    private fun buildFlags(workspaceContext: WorkspaceContext): List<String> = workspaceContext.buildFlags.values
 
-  fun setBesBackendPort(port: Int) {
-    besBackendPort = port
-  }
+    fun setBesBackendPort(port: Int) {
+        besBackendPort = port
+    }
 }

bazelrunner/src/main/java/org/jetbrains/bsp/bazel/bazelrunner/BazelRunnerBuilder.kt

@@ -11,81 +11,82 @@ open class BazelRunnerBuilder internal constructor(
     private val bazelCommand: String
 ) {
 
-  private val flags = mutableListOf<String>()
-  private val arguments = mutableListOf<String>()
-
-  fun withFlag(bazelFlag: String): BazelRunnerBuilder {
-    flags.add(bazelFlag)
-    return this
-  }
-
-  fun withFlags(bazelFlags: List<String>?): BazelRunnerBuilder {
-    flags.addAll(bazelFlags!!)
-    return this
-  }
-
-  fun withArgument(bazelArgument: String): BazelRunnerBuilder {
-    arguments.add(bazelArgument)
-    return this
-  }
-
-  fun withArguments(bazelArguments: List<String>?): BazelRunnerBuilder {
-    arguments.addAll(bazelArguments!!)
-    return this
-  }
-
-  open fun withTargets(bazelTargets: List<String>): BazelRunnerBuilder {
-    val joinedTargets = BazelArgumentsUtils.getJoinedBazelTargets(bazelTargets)
-    arguments.add(joinedTargets)
-    return this
-  }
-
-  open fun withTargets(targetsSpec: TargetsSpec): BazelRunnerBuilder {
-    val joinedTargets = BazelArgumentsUtils.joinBazelTargets(targetsSpec.values, targetsSpec.excludedValues)
-    arguments.add(joinedTargets)
-    return this
-  }
-
-  open fun withTargets(
-    includedTargets: List<BuildTargetIdentifier>,
-    excludedTargets: List<BuildTargetIdentifier>
-  ): BazelRunnerBuilder? {
-    val joinedTargets = BazelArgumentsUtils.joinBazelTargets(includedTargets, excludedTargets)
-    arguments.add(joinedTargets)
-    return this
-  }
-
-  fun withMnemonic(bazelTargets: List<String>, languageIds: List<String>): BazelRunnerBuilder {
-    val argument = BazelArgumentsUtils.getMnemonicWithJoinedTargets(bazelTargets, languageIds)
-    arguments.add(argument)
-    return this
-  }
-
-  fun withKind(bazelParameter: BazelQueryKindParameters): BazelRunnerBuilder {
-    return withKinds(ImmutableList.of(bazelParameter))
-  }
-
-  fun withKinds(bazelParameters: List<BazelQueryKindParameters>): BazelRunnerBuilder {
-    val argument = BazelArgumentsUtils.getQueryKindForPatternsAndExpressions(bazelParameters)
-    arguments.add(argument)
-    return this
-  }
-
-  fun withKindsAndExcept(
-      parameters: BazelQueryKindParameters,
-      exception: String
-  ): BazelRunnerBuilder {
-    val argument = BazelArgumentsUtils.getQueryKindForPatternsAndExpressionsWithException(
-        listOf(parameters), exception)
-    arguments.add(argument)
-    return this
-  }
-
-  fun executeBazelCommand(): BazelProcess {
-    return bazelRunner.runBazelCommand(bazelCommand, flags, arguments)
-  }
-
-  fun executeBazelBesCommand(): BazelProcess {
-    return bazelRunner.runBazelCommandBes(bazelCommand, flags, arguments)
-  }
+    private val flags = mutableListOf<String>()
+    private val arguments = mutableListOf<String>()
+
+    fun withFlag(bazelFlag: String): BazelRunnerBuilder {
+        flags.add(bazelFlag)
+        return this
+    }
+
+    fun withFlags(bazelFlags: List<String>?): BazelRunnerBuilder {
+        flags.addAll(bazelFlags!!)
+        return this
+    }
+
+    fun withArgument(bazelArgument: String): BazelRunnerBuilder {
+        arguments.add(bazelArgument)
+        return this
+    }
+
+    fun withArguments(bazelArguments: List<String>?): BazelRunnerBuilder {
+        arguments.addAll(bazelArguments!!)
+        return this
+    }
+
+    open fun withTargets(bazelTargets: List<String>): BazelRunnerBuilder {
+        val joinedTargets = BazelArgumentsUtils.getJoinedBazelTargets(bazelTargets)
+        arguments.add(joinedTargets)
+        return this
+    }
+
+    open fun withTargets(targetsSpec: TargetsSpec): BazelRunnerBuilder {
+        val joinedTargets = BazelArgumentsUtils.joinBazelTargets(targetsSpec.values, targetsSpec.excludedValues)
+        arguments.add(joinedTargets)
+        return this
+    }
+
+    open fun withTargets(
+        includedTargets: List<BuildTargetIdentifier>,
+        excludedTargets: List<BuildTargetIdentifier>
+    ): BazelRunnerBuilder? {
+        val joinedTargets = BazelArgumentsUtils.joinBazelTargets(includedTargets, excludedTargets)
+        arguments.add(joinedTargets)
+        return this
+    }
+
+    fun withMnemonic(bazelTargets: List<String>, languageIds: List<String>): BazelRunnerBuilder {
+        val argument = BazelArgumentsUtils.getMnemonicWithJoinedTargets(bazelTargets, languageIds)
+        arguments.add(argument)
+        return this
+    }
+
+    fun withKind(bazelParameter: BazelQueryKindParameters): BazelRunnerBuilder {
+        return withKinds(ImmutableList.of(bazelParameter))
+    }
+
+    fun withKinds(bazelParameters: List<BazelQueryKindParameters>): BazelRunnerBuilder {
+        val argument = BazelArgumentsUtils.getQueryKindForPatternsAndExpressions(bazelParameters)
+        arguments.add(argument)
+        return this
+    }
+
+    fun withKindsAndExcept(
+        parameters: BazelQueryKindParameters,
+        exception: String
+    ): BazelRunnerBuilder {
+        val argument = BazelArgumentsUtils.getQueryKindForPatternsAndExpressionsWithException(
+            listOf(parameters), exception
+        )
+        arguments.add(argument)
+        return this
+    }
+
+    fun executeBazelCommand(): BazelProcess {
+        return bazelRunner.runBazelCommand(bazelCommand, flags, arguments, null)
+    }
+
+    fun executeBazelBesCommand(originId: String?): BazelProcess {
+        return bazelRunner.runBazelCommandBes(bazelCommand, flags, arguments, originId)
+    }
 }

logger/src/main/java/org/jetbrains/bsp/bazel/logger/BspClientLogger.java

@@ -13,48 +13,51 @@ public class BspClientLogger {
   private static final Duration LOG_OPERATION_THRESHOLD = Duration.ofMillis(100);
   private BuildClient bspClient;
 
-  public void error(String errorMessage) {
-    log(MessageType.ERROR, errorMessage);
+  public void error(String errorMessage, String originId) {
+    log(MessageType.ERROR, errorMessage, originId);
   }
 
   public void message(String format, Object... args) {
-    message(String.format(format, args));
+    log(MessageType.LOG, String.format(format, args), null);
   }
 
-  public void message(String message) {
-    log(MessageType.LOG, message);
+  public void message(String message, String originId) {
+    log(MessageType.LOG, message, originId);
   }
 
   public void warn(String format, Object... args) {
     warn(String.format(format, args));
   }
 
   public void warn(String message) {
-    log(MessageType.WARNING, message);
+    log(MessageType.WARNING, message, null);
   }
 
-  private void log(MessageType messageType, String message) {
+  private void log(MessageType messageType, String message, String originId) {
     if (bspClient == null) return;
 
     if (!message.trim().isEmpty()) {
       var params = new LogMessageParams(messageType, message);
+      params.setOriginId(originId);
       bspClient.onBuildLogMessage(params);
     }
   }
 
-  public <T> T timed(String description, Supplier<T> supplier) {
+  public <T> T timed(String description, String originId, Supplier<T> supplier) {
     var sw = Stopwatch.start();
     T result = supplier.get();
     var duration = sw.stop();
     if (duration.compareTo(LOG_OPERATION_THRESHOLD) >= 0) {
-      message("%s completed in %s", description, Format.duration(duration));
+      message(
+          String.format("%s completed in %s", description, Format.duration(duration)), originId);
     }
     return result;
   }
 
-  public void timed(String description, Runnable runnable) {
+  public void timed(String description, String originId, Runnable runnable) {
     timed(
         description,
+        originId,
         () -> {
           runnable.run();
           return null;