Send ObjectEvent as JSON

main/src/main/scala/sbt/internal/RelayAppender.scala

@@ -10,9 +10,12 @@ import sbt.util.Level
 import sbt.internal.util._
 import sbt.protocol.LogEvent
 import sbt.internal.util.codec._
+import scala.json.ast.unsafe._
 
 class RelayAppender(name: String) extends AbstractAppender(name, null, PatternLayout.createDefaultLayout(), true) {
-  import JsonProtocol._
+  lazy val exchange = StandardMain.exchange
+  lazy val jsonFormat = new sjsonnew.BasicJsonProtocol
+    with JValueFormats {}
 
   def append(event: XLogEvent): Unit =
     {
@@ -26,10 +29,27 @@ class RelayAppender(name: String) extends AbstractAppender(name, null, PatternLa
       }
     }
   def appendLog(level: Level.Value, message: => String): Unit = {
-    StandardMain.exchange.publishEventMessage(LogEvent(level.toString, message))
+    exchange.publishEventMessage(LogEvent(level.toString, message))
   }
   def appendEvent(level: Level.Value, event: AnyRef): Unit =
     event match {
-      case x: StringEvent => StandardMain.exchange.publishEvent(x: AbstractEntry)
+      case x: StringEvent    =>
+        {
+          import JsonProtocol._
+          exchange.publishEvent(x: AbstractEntry)
+        }
+      case x: ObjectEvent[_] =>
+        {
+          import jsonFormat._
+          val json = JObject(JField("type", JString(x.contentType)), (
+            Vector(JField("message", x.json),
+              JField("level", JString(x.level.toString))) ++
+            (x.channelName.toVector map { channelName => JField("channelName", JString(channelName)) }) ++
+            (x.execId.toVector map { execId => JField("execId", JString(execId)) })): _*)
+          exchange.publishEvent(json: JValue)
+        }
+      case _                 =>
+        println(s"appendEvent: ${event.getClass}")
+        ()
     }
 }

testing/src/main/scala/sbt/internal/testing/TestLogger.scala

@@ -80,22 +80,22 @@ class TestLogger(val logging: TestLogging) extends TestsListener {
   import sbt.protocol.testing.codec.JsonProtocol._
 
   def startGroup(name: String): Unit =
-    managed.logEvent(Level.Debug, StartTestGroupEvent(name))
+    managed.logEvent(Level.Info, StartTestGroupEvent(name))
   def testEvent(event: TestEvent): Unit =
-    managed.logEvent(Level.Debug, toTestItemEvent(event))
+    managed.logEvent(Level.Info, toTestItemEvent(event))
   def endGroup(name: String, t: Throwable): Unit = {
     log.trace(t)
     log.error("Could not run test " + name + ": " + t.toString)
-    managed.logEvent(Level.Debug, EndTestGroupErrorEvent(
+    managed.logEvent(Level.Info, EndTestGroupErrorEvent(
       name,
       t.getMessage + "\n" + t.getStackTrace.toList.mkString("\n")
     ))
   }
   def endGroup(name: String, result: TestResult): Unit =
-    managed.logEvent(Level.Debug, EndTestGroupEvent(name, result))
-  def doInit: Unit = managed.logEvent(Level.Debug, TestInitEvent())
+    managed.logEvent(Level.Info, EndTestGroupEvent(name, result))
+  def doInit: Unit = managed.logEvent(Level.Info, TestInitEvent())
   /** called once, at end of test group. */
   def doComplete(finalResult: TestResult): Unit =
-    managed.logEvent(Level.Debug, TestCompleteEvent(finalResult))
+    managed.logEvent(Level.Info, TestCompleteEvent(finalResult))
   override def contentLogger(test: TestDefinition): Option[ContentLogger] = Some(logTest(test))
 }