-
Notifications
You must be signed in to change notification settings - Fork 39
/
Logger.scala
110 lines (97 loc) · 3.16 KB
/
Logger.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package reactive
package logging
case class LogEvent(subject: AnyRef, predicate: Any)
class LogLevel(val threshold: Int)
object LogLevel {
case object Trace extends LogLevel(50)
case object Debug extends LogLevel(40)
case object Info extends LogLevel(30)
case object Warn extends LogLevel(20)
case object Error extends LogLevel(10)
case object Off extends LogLevel(0)
}
/**
* This singleton manages reactive's semantic logging.
* To configure logging, forward (or foreach) events to your logging backend.
* Examples:
* Logger.traces =>> myLogger.trace
* Logger.warnings.map(_.toString) =>> myLogger.warn(_)
* for(e <- Logger.errors) System.err.println(e)
* Logger.all foreach println
* Make sure you're in the right Observing scope!
*/
object Logger {
private[reactive] val allES = new EventSource[(LogLevel, LogEvent)] {}
private val eventStreams = scala.collection.mutable.Map.empty[LogLevel, EventStream[LogEvent]]
def events(level: LogLevel) = eventStreams.synchronized {
eventStreams.getOrElseUpdate(level, allES.collect { case (`level`, e) => e })
}
/**
* Fires all semantic events, as a level -> LogEvent tuple
*/
lazy val all: EventStream[(LogLevel, LogEvent)] = allES
/**
* Fires all trace LogEvents
*/
lazy val traces: EventStream[LogEvent] = events(LogLevel.Trace)
/**
* Fires all warning LogEvents
*/
lazy val warnings: EventStream[LogEvent] = events(LogLevel.Warn)
/**
* Fires all error LogEvents
*/
lazy val errors: EventStream[LogEvent] = events(LogLevel.Error)
/**
* The log level that subsequently created Loggers should default to
*/
var defaultLevel: LogLevel = LogLevel.Warn
}
/**
* This trait supplies semantic logging capabilities.
* Logged events are fired from the corresponding
* event streams in the Logger singleton
*/
trait Logger {
@deprecated("Use reactive.logging.LogEvent", "0.4.0")
type LogEvent = reactive.logging.LogEvent
@deprecated("Use reactive.logging.LogEvent", "0.4.0")
def LogEvent = reactive.logging.LogEvent
var logLevel: LogLevel = Logger.defaultLevel
/**
* Sets the log level and returns the original instance. So for instance:
* eventSource.setLogLevel(Logger.Levels.None).fire(mouseEvent)
* val lessThanTen = eventStream.setLogLevel(Logger.Levels.Trace).filter(_ < 10)
*/
def setLogLevel(level: LogLevel): this.type = {
logLevel = level
this
}
/**
* The subject parameter that LogEvents will be created with
*/
def subject: AnyRef = this
/**
* Log a semantic event at the specified level
*/
def log(level: LogLevel, pred: => Any): Unit =
if (logLevel != null && logLevel.threshold >= level.threshold)
Logger.allES fire level -> reactive.logging.LogEvent(subject, pred)
/**
* Log a semantic event at the trace level
*/
def trace(pred: => Any): Unit = log(LogLevel.Trace, pred)
/**
* Log a semantic event at the warning level
*/
def warn(pred: => Any): Unit = log(LogLevel.Warn, pred)
/**
* Log a semantic event at the error level
*/
def error(pred: => Any): Unit = log(LogLevel.Error, pred)
}
trait HasLogger { outer =>
object logger extends Logger {
override def subject = outer
}
}