From c53c94c72ab2ef38525e847c785d2fc4ec213817 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sat, 7 May 2011 22:02:06 -0400 Subject: [PATCH] logging cleanup --- util/log/BasicLogger.scala | 12 ++++---- util/log/BufferedLogger.scala | 57 ++++++++++++++++++----------------- util/log/FullLogger.scala | 12 +++++++- 3 files changed, 47 insertions(+), 34 deletions(-) diff --git a/util/log/BasicLogger.scala b/util/log/BasicLogger.scala index f7adb11ce..c58dc57c6 100644 --- a/util/log/BasicLogger.scala +++ b/util/log/BasicLogger.scala @@ -9,10 +9,10 @@ abstract class BasicLogger extends AbstractLogger private var traceEnabledVar = java.lang.Integer.MAX_VALUE private var level: Level.Value = Level.Info private var successEnabledVar = true - def successEnabled = successEnabledVar - def setSuccessEnabled(flag: Boolean) { successEnabledVar = flag } - def getLevel = level - def setLevel(newLevel: Level.Value) { level = newLevel } - def setTrace(level: Int) { traceEnabledVar = level } - def getTrace = traceEnabledVar + def successEnabled = synchronized { successEnabledVar } + def setSuccessEnabled(flag: Boolean): Unit = synchronized { successEnabledVar = flag } + def getLevel = synchronized { level } + def setLevel(newLevel: Level.Value): Unit = synchronized { level = newLevel } + def setTrace(level: Int): Unit = synchronized { traceEnabledVar = level } + def getTrace = synchronized { traceEnabledVar } } \ No newline at end of file diff --git a/util/log/BufferedLogger.scala b/util/log/BufferedLogger.scala index 73aa7f8e5..37dbbb1df 100644 --- a/util/log/BufferedLogger.scala +++ b/util/log/BufferedLogger.scala @@ -13,21 +13,19 @@ package sbt * * This class assumes that it is the only client of the delegate logger. * */ -class BufferedLogger(delegate: AbstractLogger) extends AbstractLogger +class BufferedLogger(delegate: AbstractLogger) extends BasicLogger { private[this] val buffer = new ListBuffer[LogEvent] private[this] var recording = false /** Enables buffering. */ - def record() = { recording = true } - def buffer[T](f: => T): T = - { + def record() = synchronized { recording = true } + def buffer[T](f: => T): T = synchronized { record() try { f } finally { stopQuietly() } } - def bufferQuietly[T](f: => T): T = - { + def bufferQuietly[T](f: => T): T = synchronized { record() try { @@ -37,33 +35,36 @@ class BufferedLogger(delegate: AbstractLogger) extends AbstractLogger } catch { case e => stopQuietly(); throw e } } - private def stopQuietly() = try { stop() } catch { case e: Exception => () } + def stopQuietly() = synchronized { try { stop() } catch { case e: Exception => () } } /** Flushes the buffer to the delegate logger. This method calls logAll on the delegate * so that the messages are written consecutively. The buffer is cleared in the process. */ - def play() { delegate.logAll(buffer.readOnly); buffer.clear() } + def play(): Unit = synchronized { delegate.logAll(buffer.readOnly); buffer.clear() } /** Clears buffered events and disables buffering. */ - def clear(): Unit = { buffer.clear(); recording = false } + def clear(): Unit = synchronized { buffer.clear(); recording = false } /** Plays buffered events and disables buffering. */ - def stop() { play(); clear() } + def stop(): Unit = synchronized { play(); clear() } - def setLevel(newLevel: Level.Value) - { - buffer += new SetLevel(newLevel) - delegate.setLevel(newLevel) + override def setLevel(newLevel: Level.Value): Unit = synchronized { + super.setLevel(newLevel) + if(recording) + buffer += new SetLevel(newLevel) + else + delegate.setLevel(newLevel) } - def setSuccessEnabled(flag: Boolean) - { - buffer += new SetSuccess(flag) - delegate.setSuccessEnabled(flag) + override def setSuccessEnabled(flag: Boolean): Unit = synchronized { + super.setSuccessEnabled(flag) + if(recording) + buffer += new SetSuccess(flag) + else + delegate.setSuccessEnabled(flag) } - def successEnabled = delegate.successEnabled - def getLevel = delegate.getLevel - def getTrace = delegate.getTrace - def setTrace(level: Int) - { - buffer += new SetTrace(level) - delegate.setTrace(level) + override def setTrace(level: Int): Unit = synchronized { + super.setTrace(level) + if(recording) + buffer += new SetTrace(level) + else + delegate.setTrace(level) } def trace(t: => Throwable): Unit = @@ -72,16 +73,17 @@ class BufferedLogger(delegate: AbstractLogger) extends AbstractLogger doBufferable(Level.Info, new Success(message), _.success(message)) def log(level: Level.Value, message: => String): Unit = doBufferable(level, new Log(level, message), _.log(level, message)) - def logAll(events: Seq[LogEvent]): Unit = + def logAll(events: Seq[LogEvent]): Unit = synchronized { if(recording) buffer ++= events else delegate.logAll(events) + } def control(event: ControlEvent.Value, message: => String): Unit = doBufferable(Level.Info, new ControlEvent(event, message), _.control(event, message)) private def doBufferable(level: Level.Value, appendIfBuffered: => LogEvent, doUnbuffered: AbstractLogger => Unit): Unit = doBufferableIf(atLevel(level), appendIfBuffered, doUnbuffered) - private def doBufferableIf(condition: => Boolean, appendIfBuffered: => LogEvent, doUnbuffered: AbstractLogger => Unit): Unit = + private def doBufferableIf(condition: => Boolean, appendIfBuffered: => LogEvent, doUnbuffered: AbstractLogger => Unit): Unit = synchronized { if(condition) { if(recording) @@ -89,4 +91,5 @@ class BufferedLogger(delegate: AbstractLogger) extends AbstractLogger else doUnbuffered(delegate) } + } } \ No newline at end of file diff --git a/util/log/FullLogger.scala b/util/log/FullLogger.scala index e562fdb20..ca88f0b4d 100644 --- a/util/log/FullLogger.scala +++ b/util/log/FullLogger.scala @@ -4,8 +4,9 @@ package sbt /** Promotes the simple Logger interface to the full AbstractLogger interface. */ -class FullLogger(delegate: Logger, override val ansiCodesSupported: Boolean = false) extends BasicLogger +class FullLogger(delegate: Logger) extends BasicLogger { + override val ansiCodesSupported: Boolean = delegate.ansiCodesSupported def trace(t: => Throwable) { if(traceEnabled) @@ -23,3 +24,12 @@ class FullLogger(delegate: Logger, override val ansiCodesSupported: Boolean = fa info(message) def logAll(events: Seq[LogEvent]): Unit = events.foreach(log) } +object FullLogger +{ + def apply(delegate: Logger): AbstractLogger = + delegate match + { + case d: AbstractLogger => d + case _ => new FullLogger(delegate) + } +} \ No newline at end of file