blocks|key|3108232|text|slf4j包装器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108233|Scala的大多数日志库都是Java日志框架(+slf4j，log4j等)的包装器，但截至2015年3月，幸存下来的日志库都是slf4j。这些日志库提供了某种log对象，您可以调用info(...)、debug(...)等对其进行调用。我不太喜欢slf4j，但它现在似乎是占主导地位的日志记录框架。下面是对SLF4J的描述|offset|length|style|CODE|3108234|3108235|简单日志Facade+for+Java或(SLF4J)作为各种日志框架的简单外观或抽象，例如java.util.logging、log4j和logback，允许最终用户在部署时插入所需的日志框架。|blockquote|3108236|3108237|3108238|在部署时更改底层日志库的能力为整个slf4j记录器系列带来了独特的特征，您需要注意这一点：|3108239|3108240|类路径作为配置方法。slf4j知道您使用的是哪个底层日志库的方法是通过某个名称加载一个类。我遇到过这样的问题，当类加载器是customized.|ordered-list-item|3108241|Because时，slf4j不能识别我的记录器。简单的facade试图成为共同点，它仅限于实际的日志调用。换句话说，配置不能通过代码完成。|3108242|3108243|在一个大型项目中，如果每个人都使用slf4j，那么实际上能够控制传递依赖的日志记录行为是很方便的。|3108244|Scala日志记录|3108245|Scala+Logging是由Heiko+Seeberger编写的，作为他的slf4s的继任者。它使用宏将调用扩展到if表达式中，以避免潜在的昂贵的日志调用。|3108246|Scala是一个方便且高性能的日志库，它包装了像SLF4J和其他可能的|3108247|日志库。|3108248|3108249|3108250|历史记录器|3108251|3108252|Logula，是由Coda+Hale编写的Log4J包装器。以前喜欢这个，但现在它是abandoned.|unordered-list-item|3108253|configgy，，一个在Scala早期流行的java.util.logging包装器。现在被遗弃了。|3108254|3108255|entityMap|0|LINK|mutability|MUTABLE|url|http://www.slf4j.org/|1|https://github.com/typesafehub/scala-logging|2|https://github.com/w11k/slf4s|3|https://github.com/codahale/logula|4|https://github.com/robey/configgy^0|0|27|3|2I|9|2S|A|49|5|0|0|0|0|0|0|0|0|0|0|0|0|0|0|D|1|12|5|2|0|0|0|0|0|0|0|0|6|3|0|0|8|4|0|0^^$0|@$1|2|3|4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Y|8|@$D|1Z|E|20|F|G]|$D|21|E|22|F|G]|$D|23|E|24|F|G]]|9|@$D|25|E|26|1|27]]|A|$]]|$1|H|3|-4|5|6|7|28|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|29|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|2C|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|2E|8|@]|9|@]|A|$]]|$1|T|3|U|5|S|7|2F|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|2G|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2H|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2I|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2J|8|@]|9|@$D|2K|E|2L|1|2M]|$D|2N|E|2O|1|2P]]|A|$]]|$1|12|3|13|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|14|3|15|5|K|7|2R|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2T|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|1D|7|2W|8|@]|9|@$D|2X|E|2Y|1|2Z]]|A|$]]|$1|1E|3|1F|5|1D|7|30|8|@]|9|@$D|31|E|32|1|33]]|A|$]]|$1|1G|3|-4|5|6|7|34|8|@]|9|@]|A|$]]|$1|1H|3|-4|5|6|7|35|8|@]|9|@]|A|$]]]|1I|$1J|$5|1K|1L|1M|A|$1N|1O]]|1P|$5|1K|1L|1M|A|$1N|1Q]]|1R|$5|1K|1L|1M|A|$1N|1S]]|1T|$5|1K|1L|1M|A|$1N|1U]]|1V|$5|1K|1L|1M|A|$1N|1W]]]]

<h1>slf4j wrappers</h1>

Most of Scala's logging libraries have been some wrappers around a Java logging framework (slf4j, log4j etc), but as of March 2015, the surviving log libraries are all slf4j. These log libraries provide some sort of <code>log</code> object to which you can call <code>info(...)</code>, <code>debug(...)</code>, etc. I'm not a big fan of slf4j, but it now seems to be the predominant logging framework. Here's the description of <a href="http://www.slf4j.org/" rel="noreferrer">SLF4J</a>:

<blockquote>
 The Simple Logging Facade for Java or (SLF4J) serves as a simple facade or abstraction for various logging frameworks, e.g. java.util.logging, log4j and logback, allowing the end user to plug in the desired logging framework at deployment time.
</blockquote>

The ability to change underlying log library at deployment time brings in unique characteristic to the entire slf4j family of loggers, which you need to be aware of:

<ol>
<li>classpath as configuration approach. The way slf4j knows which underlying logging library you are using is by loading a class by some name. I've had issues in which slf4j not recognizing my logger when classloader was customized.</li>
<li>Because the simple facade tries to be the common denominator, it's limited only to actual log calls. In other words, the configuration cannot be done via the code.</li>
</ol>

In a large project, it could actually be convenient to be able to control the logging behavior of transitive dependencies if everyone used slf4j.

<h3>Scala Logging</h3>

<a href="https://github.com/typesafehub/scala-logging" rel="noreferrer">Scala Logging</a> is written by Heiko Seeberger as a successor to his <a href="https://github.com/w11k/slf4s" rel="noreferrer">slf4s</a>. It uses macro to expand calls into if expression to avoid potentially expensive log call.

<blockquote>
 Scala Logging is a convenient and performant logging library wrapping logging libraries like SLF4J and potentially others.
</blockquote>

<h1>Historical loggers</h1>

<ul>
<li><a href="https://github.com/codahale/logula" rel="noreferrer">Logula</a>, a Log4J wrapper written by Coda Hale. Used to like this one, but now it's abandoned.</li>
<li><a href="https://github.com/robey/configgy" rel="noreferrer">configgy</a>, a java.util.logging wrapper that used to be popular in the earlier days of Scala. Now abandoned.</li>
</ul>

blocks|key|340428|text|您应该看一下scalax库：http://scalax.scalaforge.org/在这个库中，有一个使用sl4j作为后端的日志记录特性。通过使用此特征，您可以非常容易地进行日志记录(只需在继承特征的类中使用记录器字段)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|340429|entityMap|0|LINK|mutability|MUTABLE|url|http://scalax.scalaforge.org/^0|E|T|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You should have a look at the scalax library :
<a href="http://scalax.scalaforge.org/" rel="nofollow noreferrer">http://scalax.scalaforge.org/</a>
In this library, there is a Logging trait, using sl4j as backend.
By using this trait, you can log quite easily (just use the logger field 
in the class inheriting the trait).

blocks|key|3321310|text|我还没有尝试过，但Configgy在配置和日志记录方面看起来都很有前途：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321311|http://github.com/robey/configgy/tree/master|offset|length|3321312|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|18|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Haven't tried it yet, but Configgy looks promising for both configuration and logging: 

<a href="http://github.com/robey/configgy/tree/master" rel="nofollow noreferrer">http://github.com/robey/configgy/tree/master</a>

blocks|key|340484|text|我从scalax的Logging特征中提取了一些工作，并创建了一个还集成了MessageFormat-based库的特征。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|340485|然后这些东西看起来像这样：|340486|class+Foo+extends+Loggable+{
++++info(+"Dude,+I'm+an+{0}+with+{1,number,#}",+"Log+message",+1234+)
}|code-block|syntax|javascript|340487|到目前为止，我们喜欢这种方法。|340488|实施：|340489|trait+Loggable+{

++++val+logger:Logger+=+Logging.getLogger(this)

++++def+checkFormat(msg:String,+refs:Seq[Any]):String+=
++++++++if+(refs.size+>+0)+msgfmtSeq(msg,+refs)+else+msg+

++++def+trace(msg:String,+refs:Any*)+=+logger+trace+checkFormat(msg,+refs)

++++def+trace(t:Throwable,+msg:String,+refs:Any*)+=+logger+trace+(checkFormat(msg,+refs),+t)

++++def+info(msg:String,+refs:Any*)+=+logger+info+checkFormat(msg,+refs)

++++def+info(t:Throwable,+msg:String,+refs:Any*)+=+logger+info+(checkFormat(msg,+refs),+t)

++++def+warn(msg:String,+refs:Any*)+=+logger+warn+checkFormat(msg,+refs)

++++def+warn(t:Throwable,+msg:String,+refs:Any*)+=+logger+warn+(checkFormat(msg,+refs),+t)

++++def+critical(msg:String,+refs:Any*)+=+logger+error+checkFormat(msg,+refs)

++++def+critical(t:Throwable,+msg:String,+refs:Any*)+=+logger+error+(checkFormat(msg,+refs),+t)

}

/**
+*+Note:+implementation+taken+from+scalax.logging+API
+*/
object+Logging+{++

++++def+loggerNameForClass(className:+String)+=+{++
++++++++if+(className+endsWith+"$")+className.substring(0,+className.length+-+1)++
++++++++else+className++
++++}++

++++def+getLogger(logging:+AnyRef)+=+LoggerFactory.getLogger(loggerNameForClass(logging.getClass.getName))++
}|340490|entityMap^0|2|6|9|7|11|J|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

I pulled a bit of work form the <code>Logging</code> trait of <code>scalax</code>, and created a trait that also integrated a <code>MessageFormat-based</code> library.

Then stuff kind of looks like this:

<pre><code>class Foo extends Loggable {
 info( "Dude, I'm an {0} with {1,number,#}", "Log message", 1234 )
}
</code></pre>

We like the approach so far.

Implementation:

<pre><code>trait Loggable {

 val logger:Logger = Logging.getLogger(this)

 def checkFormat(msg:String, refs:Seq[Any]):String =
 if (refs.size &gt; 0) msgfmtSeq(msg, refs) else msg 

 def trace(msg:String, refs:Any*) = logger trace checkFormat(msg, refs)

 def trace(t:Throwable, msg:String, refs:Any*) = logger trace (checkFormat(msg, refs), t)

 def info(msg:String, refs:Any*) = logger info checkFormat(msg, refs)

 def info(t:Throwable, msg:String, refs:Any*) = logger info (checkFormat(msg, refs), t)

 def warn(msg:String, refs:Any*) = logger warn checkFormat(msg, refs)

 def warn(t:Throwable, msg:String, refs:Any*) = logger warn (checkFormat(msg, refs), t)

 def critical(msg:String, refs:Any*) = logger error checkFormat(msg, refs)

 def critical(t:Throwable, msg:String, refs:Any*) = logger error (checkFormat(msg, refs), t)

}

/**
 * Note: implementation taken from scalax.logging API
 */
object Logging { 

 def loggerNameForClass(className: String) = { 
 if (className endsWith "$") className.substring(0, className.length - 1) 
 else className 
 } 

 def getLogger(logging: AnyRef) = LoggerFactory.getLogger(loggerNameForClass(logging.getClass.getName)) 
}
</code></pre>

blocks|key|3321360|text|使用slf4j和包装器是很好的，但是当您有两个以上的值要插值时，它内置在插值中的使用就会中断，因为那时您需要创建一个要插值的值数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321361|一种更像Scala的解决方案是使用thunk或集群来延迟错误消息的连接。Lift的记录器就是一个很好的例子|3321362|Log.scala+Slf4jLog.scala|offset|length|3321363|它看起来像这样：|3321364|class+Log4JLogger(val+logger:+Logger)+extends+LiftLogger+{
++override+def+trace(msg:+=>+AnyRef)+=+if+(isTraceEnabled)+logger.trace(msg)
}|code-block|syntax|javascript|3321365|请注意，msg是按名称调用的，除非isTraceEnabled为true，否则不会进行计算，因此生成良好的消息字符串不会产生任何成本。这绕过了slf4j的插值机制，该机制需要解析错误消息。使用此模型，您可以在错误消息中插入任意数量的值。|3321366|如果您有一个单独的特征将此Log4JLogger混合到您的类中，那么您可以这样做|3321367|trace("The+foobar+from+"+%2B+a+%2B+"+doesn't+match+the+foobar+from+"+%2B
++++++b+%2B+"+and+you+should+reset+the+baz+from+"+%2B+c")|3321368|而不是|3321369|info("The+foobar+from+{0}+doesn't+match+the+foobar+from+{1}+and+you+should+reset+the+baz+from+{c},
+++++Array(a,+b,+c))|3321370|entityMap|0|LINK|mutability|MUTABLE|url|http://github.com/dpp/liftweb/blob/fe26cc3bff335b4f428194cf4c2e7f6818fb0cbe/lift-util/src/main/scala/net/liftweb/util/Log.scala|1|http://github.com/dpp/liftweb/blob/fe26cc3bff335b4f428194cf4c2e7f6818fb0cbe/lift-util/src/main/scala/net/liftweb/util/Slf4jLog.scala^0|0|0|0|9|0|A|E|1|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@$F|1B|G|1C|1|1D]|$F|1E|G|1F|1|1G]]|A|$]]|$1|H|3|I|5|6|7|1H|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1I|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|U|3|V|5|6|7|1M|8|@]|9|@]|A|$]]|$1|W|3|X|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|Y|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

Using slf4j and a wrapper is nice but the use of it's built in interpolation breaks down when you have more than two values to interpolate, since then you need to create an Array of values to interpolate.

A more Scala like solution is to use a thunk or cluster to delay the concatenation of the error message. A good example of this is Lift's logger

<a href="http://github.com/dpp/liftweb/blob/fe26cc3bff335b4f428194cf4c2e7f6818fb0cbe/lift-util/src/main/scala/net/liftweb/util/Log.scala" rel="noreferrer">Log.scala</a>
<a href="http://github.com/dpp/liftweb/blob/fe26cc3bff335b4f428194cf4c2e7f6818fb0cbe/lift-util/src/main/scala/net/liftweb/util/Slf4jLog.scala" rel="noreferrer">Slf4jLog.scala</a>

Which looks like this:

<pre><code>class Log4JLogger(val logger: Logger) extends LiftLogger {
 override def trace(msg: =&gt; AnyRef) = if (isTraceEnabled) logger.trace(msg)
}
</code></pre>

Note that msg is a call-by-name and won't be evaluated unless isTraceEnabled is true so there's no cost in generating a nice message string. This works around the slf4j's interpolation mechanism which requires parsing the error message. With this model, you can interpolate any number of values into the error message.

If you have a separate trait that mixes this Log4JLogger into your class, then you can do

<pre><code>trace("The foobar from " + a + " doesn't match the foobar from " +
 b + " and you should reset the baz from " + c")
</code></pre>

instead of

<pre><code>info("The foobar from {0} doesn't match the foobar from {1} and you should reset the baz from {c},
 Array(a, b, c))
</code></pre>

blocks|key|3321412|text|Writer、Monoid和一个Monad实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3321413|entityMap^0|0|6|7|6|G|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

<code>Writer</code>, <code>Monoid</code> and a <code>Monad</code> implementation.

blocks|key|340554|text|在使用了slf4s和logula一段时间后，我编写了loglady，这是一个包装slf4j的简单日志记录特征。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|340555|它提供了一个类似于Python的日志库的API，这使得常见的情况(基本字符串、简单格式化)变得微不足道，并避免了格式化样板。|340556|http://github.com/dln/loglady/|340557|entityMap|0|LINK|mutability|MUTABLE|url^0|Q|7|0|0|0|U|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|U|8|@]|D|@$9|V|A|W|1|X]]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|I]]]]

After using slf4s and logula for a while, I wrote <code>loglady</code>, a simple logging trait wrapping slf4j. 

It offers an API similar to that of Python's logging library, which makes the common cases (basic string, simple formatting) trivial and avoids formatting boilerplate.

<a href="http://github.com/dln/loglady/" rel="nofollow">http://github.com/dln/loglady/</a>

blocks|key|3321524|text|我使用SLF4J+%2B+Logback+classic，并像这样应用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321525|trait+Logging+{
++lazy+val+logger+=+LoggerFactory.getLogger(getClass)

++implicit+def+logging2Logger(anything:+Logging):+Logger+=+anything.logger
}|code-block|syntax|javascript|3321526|然后，您可以使用它更适合您的风格：|3321527|class+X+with+Logging+{
++++logger.debug("foo")
++++debug("bar")
}|3321528|但是这种方法当然会为每个类实例使用一个记录器实例。|3321529|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I use SLF4J + Logback classic and apply it like this:

<pre><code>trait Logging {
 lazy val logger = LoggerFactory.getLogger(getClass)

 implicit def logging2Logger(anything: Logging): Logger = anything.logger
}
</code></pre>

Then you can use it whichever fits your style better:

<pre><code>class X with Logging {
 logger.debug("foo")
 debug("bar")
}
</code></pre>

but this approach of course uses a logger instance per class instance.

blocks|key|3321600|text|不要使用Logula|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321601|实际上，我遵循了尤金的建议，并尝试了一下，发现它有一个笨拙的配置，并受到错误的影响，这些错误无法修复(比如this+one)。它看起来没有得到很好的维护，而且它的不支持Scala+2.10。|offset|length|style|BOLD|3321602|使用slf4s+%2B+slf4j-simple|3321603|主要优势：|3321604|3321605|Supports最新的Scala2.10(到目前为止，它的M7)|unordered-list-item|3321606|Configuration是通用的，但是再简单不过了。这是使用system+properties完成的，您可以通过在执行命令中附加类似-Dorg.slf4j.simplelogger.defaultlog=trace的内容或在脚本中硬编码来设置：System.setProperty("org.slf4j.simplelogger.defaultlog",+"trace")。不需要管理无用的配置文件！|CODE|3321607|非常适合IDE。例如，要在IDEA中的特定运行配置中将日志记录级别设置为“跟踪”，只需转到Run/Debug+Configurations并将依赖项添加到VM+options.|3321608|Easy设置:只需从此答案的底部插入依赖项|3321609|即可|3321610|以下是在Maven中运行它所需的内容：|3321611|<dependency>
++<groupId>com.weiglewilczek.slf4s</groupId>
++<artifactId>slf4s_2.9.1</artifactId>
++<version>1.0.7</version>
</dependency>
<dependency>
++<groupId>org.slf4j</groupId>
++<artifactId>slf4j-simple</artifactId>
++<version>1.6.6</version>
</dependency>|code-block|syntax|javascript|3321612|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/codahale/logula/pull/4|1|http://www.slf4j.org/api/org/slf4j/impl/SimpleLogger.html^0|0|29|D|1H|8|0|0|0|0|0|0|K|0|1V|15|3F|1S|V|H|1|0|19|O|25|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1G|8|@$D|1H|E|1I|F|G]]|9|@$D|1J|E|1K|1|1L]]|A|$]]|$1|H|3|I|5|6|7|1M|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1N|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1P|8|@$D|1Q|E|1R|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|O|7|1S|8|@$D|1T|E|1U|F|R]|$D|1V|E|1W|F|R]]|9|@$D|1X|E|1Y|1|1Z]]|A|$]]|$1|S|3|T|5|O|7|20|8|@$D|21|E|22|F|R]|$D|23|E|24|F|R]]|9|@]|A|$]]|$1|U|3|V|5|O|7|25|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|26|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|27|8|@]|9|@]|A|$]]|$1|10|3|11|5|12|7|28|8|@]|9|@]|A|$13|14]]|$1|15|3|-4|5|6|7|29|8|@]|9|@]|A|$]]]|16|$17|$5|18|19|1A|A|$1B|1C]]|1D|$5|18|19|1A|A|$1B|1E]]]]

<h2>Don't use Logula</h2>
I've actually followed the recommendation of Eugene and tried it and found out that it has a clumsy configuration and is subjected to bugs, which don't get fixed (such as <a href="https://github.com/codahale/logula/pull/4" rel="noreferrer">this one</a>). It doesn't look to be well maintained and it doesn't support Scala 2.10.
<h1>Use slf4s + slf4j-simple</h1>
<h2>Key benefits:</h2>
<ul>
<li>Supports latest Scala 2.10 (to date it's M7)</li>
<li>Configuration is versatile but couldn't be simpler. It's done with <a href="http://www.slf4j.org/api/org/slf4j/impl/SimpleLogger.html" rel="noreferrer">system properties</a>, which you can set either by appending something like <code>-Dorg.slf4j.simplelogger.defaultlog=trace</code> to execution command or hardcode in your script: <code>System.setProperty(&quot;org.slf4j.simplelogger.defaultlog&quot;, &quot;trace&quot;)</code>. No need to manage trashy config files!</li>
<li>Fits nicely with IDEs. For instance to set the logging level to &quot;trace&quot; in a specific run configuration in IDEA just go to <code>Run/Debug Configurations</code> and add <code>-Dorg.slf4j.simplelogger.defaultlog=trace</code> to <code>VM options</code>.</li>
<li>Easy setup: just drop in the dependencies from the bottom of this answer</li>
</ul>
Here's what you need to be running it with Maven:
<pre><code>&lt;dependency&gt;
 &lt;groupId&gt;com.weiglewilczek.slf4s&lt;/groupId&gt;
 &lt;artifactId&gt;slf4s_2.9.1&lt;/artifactId&gt;
 &lt;version&gt;1.0.7&lt;/version&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
 &lt;groupId&gt;org.slf4j&lt;/groupId&gt;
 &lt;artifactId&gt;slf4j-simple&lt;/artifactId&gt;
 &lt;version&gt;1.6.6&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>

blocks|key|342918|text|对于ScalaLogging，可以考虑ScalaLogging+by+Typesafe。使用宏来提供非常干净的API|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342919|https://github.com/typesafehub/scala-logging|offset|length|342920|引用他们的维基：|342921|342922|幸运的是，Scala宏可以让我们的生活更轻松:+ScalaLogging为Logger类提供了轻量级的日志记录方法，这些方法将扩展到上面的习惯用法。所以我们要写的就是：|blockquote|style|CODE|342923|342924|342925|logger.debug(s"Some+${expensiveExpression}+message!")|code-block|syntax|javascript|342926|在应用宏之后，代码将被转换为上述习惯用法。|342927|此外，ScalaLogging提供了特征Logging，它方便地提供了一个Logger实例，该实例使用混合在以下文件中的类名进行初始化：|342928|import+com.typesafe.scalalogging.slf4j.LazyLogging

class+MyClass+extends+LazyLogging+{
++logger.debug("This+is+very+convenient+;-)")
}|342929|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|18|0|0|0|0|11|6|0|0|0|0|0|K|7|11|6|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|F|3|G|5|6|7|1C|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1E|8|@$D|1F|E|1G|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1J|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1L|8|@$D|1M|E|1N|L|M]|$D|1O|E|1P|L|M]]|9|@]|A|$]]|$1|Y|3|Z|5|R|7|1Q|8|@]|9|@]|A|$S|T]]|$1|10|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|C]]]]

With Scala 2.10+ Consider ScalaLogging by Typesafe. Uses macros to deliver a very clean API

<a href="https://github.com/typesafehub/scala-logging" rel="noreferrer">https://github.com/typesafehub/scala-logging</a>

Quoting from their wiki:

<blockquote>
 Fortunately Scala macros can be used to make our lives easier: ScalaLogging offers the class <code>Logger</code> with lightweight logging methods that will be expanded to the above idiom. So all we have to write is:
</blockquote>

<pre><code>logger.debug(s"Some ${expensiveExpression} message!")
</code></pre>

After the macro has been applied, the code will have been transformed into the above described idiom.

In addition ScalaLogging offers the trait <code>Logging</code> which conveniently provides a <code>Logger</code> instance initialized with the name of the class mixed into:

<pre class="lang-scala prettyprint-override"><code>import com.typesafe.scalalogging.slf4j.LazyLogging

class MyClass extends LazyLogging {
 logger.debug("This is very convenient ;-)")
}
</code></pre>

blocks|key|339457|text|我发现使用某种java记录器非常方便，例如sl4j，它带有简单的scala包装器，它为我带来了这样的语法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339458|val+#!+=+new+Logger(..)+//+somewhere+deep+in+dsl.logging.

object+User+with+dsl.logging+{

++#!+!+"info+message"
++#!+dbg+"debug+message"
++#!+trace+"var+a=true"

}|code-block|syntax|javascript|339459|在我看来，java成熟的日志框架和scala的奇特语法的混合非常有用。|339460|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I find very convenient using some kind of java logger, sl4j for example, with simple scala wrapper, which brings me such syntax

<pre><code>val #! = new Logger(..) // somewhere deep in dsl.logging.

object User with dsl.logging {

 #! ! "info message"
 #! dbg "debug message"
 #! trace "var a=true"

}
</code></pre>

In my opinion very usefull mixin of java proven logging frameworks and scala's fancy syntax.

blocks|key|340635|text|这就是我让Scala+Logging为我工作的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|340636|把这个放到你的build.sbt里|style|CODE|340637|libraryDependencies+%2B=+"com.typesafe.scala-logging"+%25%25+"scala-logging"+%25+"3.7.2",
libraryDependencies+%2B=+"ch.qos.logback"+%25+"logback-classic"+%25+"1.2.3"|code-block|syntax|javascript|340638|然后，在执行sbt+update之后，它会打印出一条友好的日志消息：|340639|import+com.typesafe.scalalogging._
object+MyApp+extends+App+with+LazyLogging+{
++logger.info("Hello+there")
}|340640|如果您正在使用Play，当然可以简单地使用import+play.api.Logger来写入日志消息：Logger.debug("Hi")。|340641|有关更多信息，请参阅docs。|340642|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/typesafehub/scala-logging|1|https://www.playframework.com/documentation/2.6.x/ScalaLogging^0|5|D|0|0|7|9|0|0|6|A|0|0|L|M|1F|I|0|A|4|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@$A|19|B|1A|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1B|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1C|8|@$A|1D|B|1E|F|G]]|9|@]|C|$]]|$1|O|3|P|5|J|7|1F|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1G|8|@$A|1H|B|1I|F|G]|$A|1J|B|1K|F|G]]|9|@]|C|$]]|$1|S|3|T|5|6|7|1L|8|@]|9|@$A|1M|B|1N|1|1O]]|C|$]]|$1|U|3|-4|5|6|7|1P|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

This is how I got <a href="https://github.com/typesafehub/scala-logging" rel="nofollow noreferrer">Scala Logging</a> working for me:

Put this in your <code>build.sbt</code>:

<pre><code>libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.7.2",
libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3"
</code></pre>

Then, after doing an <code>sbt update</code>, this prints out a friendly log message:

<pre><code>import com.typesafe.scalalogging._
object MyApp extends App with LazyLogging {
 logger.info("Hello there")
}
</code></pre>

If you are using Play, you can of course simply <code>import play.api.Logger</code> for writing log messages: <code>Logger.debug("Hi")</code>.

See the <a href="https://www.playframework.com/documentation/2.6.x/ScalaLogging" rel="nofollow noreferrer">docs</a> for more info.

blocks|key|3321707|text|快速简单的表单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3321708|Scala+2.10及更早版本：|3321709|import+com.typesafe.scalalogging.slf4j.Logger
import+org.slf4j.LoggerFactory
val+logger+=+Logger(LoggerFactory.getLogger("TheLoggerName"))
logger.debug("Useful+message....")|code-block|syntax|javascript|3321710|和build.sbt：|3321711|libraryDependencies+%2B=+"com.typesafe"+%25%25+"scalalogging-slf4j"+%25+"1.1.0"|3321712|Scala+2.11%2B及更高版本：|3321713|import+import+com.typesafe.scalalogging.Logger
import+org.slf4j.LoggerFactory
val+logger+=+Logger(LoggerFactory.getLogger("TheLoggerName"))
logger.debug("Useful+message....")|3321714|3321715|libraryDependencies+%2B=+"com.typesafe.scala-logging"+%25%25+"scala-logging"+%25+"3.1.0"|3321716|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|Q|3|J|5|6|7|12|8|@]|9|@]|A|$]]|$1|R|3|S|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|T|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|U|$]]

Quick and easy forms.

Scala 2.10 and older:

<pre><code>import com.typesafe.scalalogging.slf4j.Logger
import org.slf4j.LoggerFactory
val logger = Logger(LoggerFactory.getLogger("TheLoggerName"))
logger.debug("Useful message....")
</code></pre>

And build.sbt:

<pre><code>libraryDependencies += "com.typesafe" %% "scalalogging-slf4j" % "1.1.0"
</code></pre>

Scala 2.11+ and newer:

<pre><code>import import com.typesafe.scalalogging.Logger
import org.slf4j.LoggerFactory
val logger = Logger(LoggerFactory.getLogger("TheLoggerName"))
logger.debug("Useful message....")
</code></pre>

And build.sbt:

<pre><code>libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.1.0"
</code></pre>

blocks|key|342963|text|2020年的登录|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342964|我真的很惊讶，我在工作中使用的Scribe日志记录框架在这里甚至都没有提到。更重要的是，在搜索"scala+logging“之后，它甚至没有出现在Google的首页上。但是这个页面会在谷歌搜索的时候出现！所以让我把它留在这里。|offset|length|342965|Scribe的主要优势：|342966|https://www.matthicks.com/2018/02/scribe-2-fastest-jvm-logger-in-world.html：|342967|it+is+NOT+a+slf4j+wrapper|unordered-list-item|style|BOLD|342968|supports+also+Scala.js+and+Scala+Native|342969|它真的很快，在这里查看比较：|342970|342971|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/outr/scribe|1|https://www.matthicks.com/2018/02/scribe-2-fastest-jvm-logger-in-world.html^0|0|F|6|0|0|0|0|23|1|0|6|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|J|3|K|5|L|7|1D|8|@$D|1E|E|1F|M|N]]|9|@]|A|$]]|$1|O|3|P|5|L|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1H|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]|11|$5|W|X|Y|A|$Z|12]]]]

<h2>Logging in 2020</h2>
I was really surprised that <a href="https://github.com/outr/scribe" rel="noreferrer">Scribe</a> logging framework that I use at work isn't even mentioned here. What is more, it doesn't even appear on the first page in Google after searching &quot;scala logging&quot;. But this page appears when googling it! So let me leave that here.
Main advantages of Scribe:
<ul>
<li>it is NOT a slf4j wrapper</li>
<li>supports also Scala.js and Scala Native</li>
<li>it is really fast, check comparison here: <a href="https://www.matthicks.com/2018/02/scribe-2-fastest-jvm-logger-in-world.html" rel="noreferrer">https://www.matthicks.com/2018/02/scribe-2-fastest-jvm-logger-in-world.html</a></li>
</ul>

What is a good way to do logging in a Scala application? Something that is consistent with the language philosophy, does not clutter the code, and is low-maintenance and unobtrusive. Here's a basic requirement list:

<ul>
<li>simple</li>
<li>does not clutter the code. Scala is great for its brevity. I don't want half of my code to be logging statements</li>
<li>log format can be changed to fit the rest of my enterprise logs and monitoring software</li>
<li>supports levels of logging (ie debug, trace, error)</li>
<li>can log to disk as well as other destinations (i.e. socket, console, etc.)</li>
<li>minimum configuration, if any</li>
<li>works in containers (ie, web server)</li>
<li>(optional, but nice to have) comes either as part of the language or as a maven artifact, so I don't have to hack my builds to use it</li>
</ul>

I know I can use the existing Java logging solutions, but they fail on at least two of the above, namely clutter and configuration.

Thanks for your replies.

Logging in Scala

容器

Python

Java

在Scala应用程序中记录日志的好方法是什么？一些符合语言哲学的东西，不会弄乱代码，并且是低维护和不显眼的。以下是基本需求列表：simpledoes不会使代码变得混乱。Scala非常简洁。我不希望我的一半代码成为日志语句，为了适应我的企业日志和监控softwaresupports级别的日志(即调试、跟踪、错误)，可以更...

问Scala中的日志记录
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala中的日志记录EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala中的日志记录
EN