aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/xyz/driver/core/logging.scala
blob: 599c824b91eb75f52623ca9ae8610fa085e65007 (plain) (blame)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
package xyz.driver.core

import java.text.SimpleDateFormat
import java.util.Date

import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.LayoutBase
import org.apache.commons.lang3.StringUtils
import org.slf4j.Marker

object logging {

  trait Logger {

    def fatal(message: String): Unit
    def fatal(message: String, cause: Throwable): Unit
    def fatal(message: String, args: AnyRef*): Unit
    def fatal(marker: Marker, message: String): Unit
    def fatal(marker: Marker, message: String, cause: Throwable): Unit
    def fatal(marker: Marker, message: String, args: AnyRef*): Unit

    def error(message: String): Unit
    def error(message: String, cause: Throwable): Unit
    def error(message: String, args: AnyRef*): Unit
    def error(marker: Marker, message: String): Unit
    def error(marker: Marker, message: String, cause: Throwable): Unit
    def error(marker: Marker, message: String, args: AnyRef*): Unit

    def audit(message: String): Unit
    def audit(message: String, cause: Throwable): Unit
    def audit(message: String, args: AnyRef*): Unit
    def audit(marker: Marker, message: String): Unit
    def audit(marker: Marker, message: String, cause: Throwable): Unit
    def audit(marker: Marker, message: String, args: AnyRef*): Unit

    def debug(message: String): Unit
    def debug(message: String, cause: Throwable): Unit
    def debug(message: String, args: AnyRef*): Unit
    def debug(marker: Marker, message: String): Unit
    def debug(marker: Marker, message: String, cause: Throwable): Unit
    def debug(marker: Marker, message: String, args: AnyRef*): Unit
  }

  /**
    * Logger implementation which uses `com.typesafe.scalalogging.Logger` on the back.
    * It redefines the meaning of logging levels to fit to the Driver infrastructure design,
    * and as using error and warn, debug and trace was always confusing and mostly done wrong.
    *
    * @param scalaLogging com.typesafe.scalalogging.Logger which logging will be delegated to
    */
  class TypesafeScalaLogger(scalaLogging: com.typesafe.scalalogging.Logger) extends Logger {

    def fatal(message: String): Unit                   = scalaLogging.error("FATAL " + message)
    def fatal(message: String, cause: Throwable): Unit = scalaLogging.error("FATAL " + message, cause)
    def fatal(message: String, args: AnyRef*): Unit    = scalaLogging.error("FATAL " + message, args)
    def fatal(marker: Marker, message: String): Unit   = scalaLogging.error(marker, "FATAL " + message)
    def fatal(marker: Marker, message: String, cause: Throwable): Unit =
      scalaLogging.error(marker, "FATAL " + message, cause)
    def fatal(marker: Marker, message: String, args: AnyRef*): Unit =
      scalaLogging.error(marker, "FATAL " + message, args)

    def error(message: String): Unit                   = scalaLogging.warn("ERROR " + message)
    def error(message: String, cause: Throwable): Unit = scalaLogging.warn("ERROR " + message, cause)
    def error(message: String, args: AnyRef*): Unit    = scalaLogging.warn("ERROR " + message, args)
    def error(marker: Marker, message: String): Unit   = scalaLogging.warn(marker, "ERROR " + message)
    def error(marker: Marker, message: String, cause: Throwable): Unit =
      scalaLogging.warn(marker, "ERROR " + message, cause)
    def error(marker: Marker, message: String, args: AnyRef*): Unit =
      scalaLogging.warn(marker, "ERROR " + message, args)

    def audit(message: String): Unit                   = scalaLogging.info("AUDIT " + message)
    def audit(message: String, cause: Throwable): Unit = scalaLogging.info("AUDIT " + message, cause)
    def audit(message: String, args: AnyRef*): Unit    = scalaLogging.info("AUDIT " + message, args)
    def audit(marker: Marker, message: String): Unit   = scalaLogging.info(marker, "AUDIT " + message)
    def audit(marker: Marker, message: String, cause: Throwable): Unit =
      scalaLogging.info(marker, "AUDIT " + message, cause)
    def audit(marker: Marker, message: String, args: AnyRef*): Unit =
      scalaLogging.info(marker, "AUDIT " + message, args)

    def debug(message: String): Unit                   = scalaLogging.debug("DEBUG " + message)
    def debug(message: String, cause: Throwable): Unit = scalaLogging.debug("DEBUG " + message, cause)
    def debug(message: String, args: AnyRef*): Unit    = scalaLogging.debug("DEBUG " + message, args)
    def debug(marker: Marker, message: String): Unit   = scalaLogging.debug(marker, "DEBUG " + message)
    def debug(marker: Marker, message: String, cause: Throwable): Unit =
      scalaLogging.debug(marker, "DEBUG " + message, cause)
    def debug(marker: Marker, message: String, args: AnyRef*): Unit =
      scalaLogging.debug(marker, "DEBUG " + message, args)
  }

  class NoLogger() extends Logger {

    def fatal(message: String): Unit                                   = {}
    def fatal(message: String, cause: Throwable): Unit                 = {}
    def fatal(message: String, args: AnyRef*): Unit                    = {}
    def fatal(marker: Marker, message: String): Unit                   = {}
    def fatal(marker: Marker, message: String, cause: Throwable): Unit = {}
    def fatal(marker: Marker, message: String, args: AnyRef*): Unit    = {}

    def error(message: String): Unit                                   = {}
    def error(message: String, cause: Throwable): Unit                 = {}
    def error(message: String, args: AnyRef*): Unit                    = {}
    def error(marker: Marker, message: String): Unit                   = {}
    def error(marker: Marker, message: String, cause: Throwable): Unit = {}
    def error(marker: Marker, message: String, args: AnyRef*): Unit    = {}

    def audit(message: String): Unit                                   = {}
    def audit(message: String, cause: Throwable): Unit                 = {}
    def audit(message: String, args: AnyRef*): Unit                    = {}
    def audit(marker: Marker, message: String): Unit                   = {}
    def audit(marker: Marker, message: String, cause: Throwable): Unit = {}
    def audit(marker: Marker, message: String, args: AnyRef*): Unit    = {}

    def debug(message: String): Unit                                   = {}
    def debug(message: String, cause: Throwable): Unit                 = {}
    def debug(message: String, args: AnyRef*): Unit                    = {}
    def debug(marker: Marker, message: String): Unit                   = {}
    def debug(marker: Marker, message: String, cause: Throwable): Unit = {}
    def debug(marker: Marker, message: String, args: AnyRef*): Unit    = {}
  }

  class DriverLayout extends LayoutBase[ILoggingEvent] {
    import scala.collection.JavaConverters._

    private val AVERAGE_MAXIMAL_MESSAGE_LENGTH = 256
    private val FieldSeparator                 = "="
    private val DateFormatString               = "MM/dd/yyyy HH:mm:ss"
    private val newline                        = System.getProperty("line.separator")
    private val IgnoredClassesInStack          = Set("org.apache.catalina", "org.apache.coyote", "sun.reflect", "javax.servlet")

    override def doLayout(loggingEvent: ILoggingEvent): String = {

      val message = new StringBuilder(AVERAGE_MAXIMAL_MESSAGE_LENGTH)
        .append(new SimpleDateFormat(DateFormatString).format(new Date(loggingEvent.getTimeStamp)))
        .append(" [")
        .append(StringUtils.rightPad(loggingEvent.getLevel.toString, 5))
        .append(']')
        .append(" - ")
        .append(loggingEvent.getMessage)
        .append(newline)

      logContext(message, loggingEvent)

      Option(loggingEvent.getCallerData) foreach { stacktrace =>
        val stacktraceLength = stacktrace.length

        if (stacktraceLength > 0) {
          val location = stacktrace.head

          val _ = message
            .append(s"Location: ${location.getClassName}.${location.getMethodName}:${location.getLineNumber}$newline")
            .append("Exception: ")
            .append(location.toString)
            .append(newline)

          if (stacktraceLength > 1) {
            message.append(stacktrace.tail.filterNot { e =>
              IgnoredClassesInStack.forall(ignored => !e.getClassName.startsWith(ignored))
            } map {
              _.toString
            } mkString newline)
          }
        }
      }

      message.toString
    }

    private def logContext(message: StringBuilder, loggingEvent: ILoggingEvent) = {
      Option(loggingEvent.getMDCPropertyMap).map(_.asScala).filter(_.nonEmpty).foreach { context =>
        message.append(
          context map { case (key, value) => s"$key$FieldSeparator$value" } mkString ("Context: ", " ", newline)
        )
      }
    }
  }
}