Scala uygulamasında günlük kaydı yapmanın iyi bir yolu nedir? Dil felsefesi ile uyumlu olan bir şey, kodu karmaşıklaştırmaz ve az bakım gerektiren ve göze batmayan bir şeydir. Temel bir gereksinim listesi:

• basit
• kodu karıştırmaz. Scala kısalığı için mükemmeldir. Kodumun yarısının ifadeleri günlüğe kaydetmesini istemiyorum
• günlük biçimi, kurumsal günlüklerimin ve izleme yazılımımın geri kalanına uyacak şekilde değiştirilebilir
• günlük düzeylerini destekler (örneğin, hata ayıklama, izleme, hata)
• diske ve diğer hedeflere (soket, konsol vb.) giriş yapabilir
• varsa minimum yapılandırma
• kapsayıcılarda çalışır (web sunucusu gibi)
• (isteğe bağlı, ancak sahip olmak güzel) dilin bir parçası veya bir maven artefaktı olarak geliyor, bu yüzden onu kullanmak için yapılarımı kesmek zorunda değilim

Mevcut Java günlükleme çözümlerini kullanabileceğimi biliyorum, ancak yukarıdakilerden en az ikisinde, yani dağınıklık ve yapılandırmada başarısız oluyorlar.

Cevaplarınız için teşekkürler.

slf4j sarmalayıcılar

Scala günlük kayıt kitaplıklarının çoğu, Java günlük kayıt çerçevesi (slf4j, log4j vb.) Etrafındaki bazı paketleyicilerdir, ancak Mart 2015 itibarıyla, hayatta kalan günlük kitaplıklarının tümü slf4j'dir. Bu günlük kütüphaneleri çeşit sağlamak logArayabileceğin hangi nesneye info(...), debug(...)vb ben slf4j büyük bir hayranı değilim, ama şimdi baskın günlük çerçeve gibi görünüyor. SLF4J açıklaması :

Java için Basit Logging Facade veya (SLF4J), java.util.logging, log4j ve logback gibi çeşitli günlükleme çerçeveleri için basit bir cephe veya soyutlama işlevi görür ve son kullanıcının istediği günlükleme çerçevesini dağıtım zamanında takmasına olanak tanır.

Dağıtım zamanında temel günlük kitaplığını değiştirme yeteneği, tüm bilmeniz gereken tüm slf4j günlük kaydedici ailesine benzersiz bir özellik kazandırır:

1. yapılandırma yaklaşımı olarak sınıfyolu . Slf4j'nin hangi temel günlükleme kütüphanesini kullandığınızı bilmesi, bir sınıfı bir ada göre yüklemektir. Classfloader özelleştirildiğinde slf4j benim logger tanımıyor sorunları yaşadım.
2. Çünkü basit cephe ortak paydayı olmaya çalışır, sadece fiili günlük çağrılarına sınırlı. Başka bir deyişle, yapılandırma kod üzerinden yapılamaz.

Büyük bir projede, herkes slf4j kullansaydı, geçişli bağımlılıkların günlük tutma davranışını kontrol edebilmek uygun olabilir.

Scala Günlüğü

Scala Logging , Heiko Seeberger tarafından slf4'lerinin halefi olarak yazılmıştır . Potansiyel olarak pahalı günlük çağrısını önlemek için ifadeleri if ifadesine genişletmek için makro kullanır.

Scala Logging, SLF4J ve potansiyel olarak diğerleri gibi günlük kütüphanelerini saran kullanışlı ve performanslı bir günlük kütüphanesidir.

Tarihsel günlük kaydediciler

• Logula , Coda Hale tarafından yazılmış bir Log4J ambalajı. Bunu sevdim, ama şimdi terk edildi.
• Scala'nın ilk günlerinde popüler olan bir java.util.logging sarmalayıcısı olan configgy . Şimdi terk edildi.

Scala 2.10+ ile Typesafe tarafından ScalaLogging'i düşünün. Çok temiz bir API sunmak için makrolar kullanır

https://github.com/typesafehub/scala-logging

Wiki'sinden alıntılar:

Neyse ki Scala makroları hayatımızı kolaylaştırmak için kullanılabilir: ScalaLogging, sınıfa Loggeryukarıdaki deyime kadar genişletilecek hafif günlükleme yöntemleri sunar . Yani yazmamız gereken tek şey:

logger.debug(s"Some ${expensiveExpression} message!")

Makro uygulandıktan sonra, kod yukarıda açıklanan deyime dönüştürülmüş olacaktır.

Ek olarak ScalaLogging , sınıfın adıyla karıştırılmış Loggingbir Loggerörneği uygun bir şekilde sağlayan özelliği sunar :

import com.typesafe.scalalogging.slf4j.LazyLogging

class MyClass extends LazyLogging {
  logger.debug("This is very convenient ;-)")
}

Slf4j ve bir sarıcı kullanmak güzeldir ancak enterpolasyonda yerleşik olarak kullanılması enterpolasyon için ikiden fazla değeriniz olduğunda bozulur, çünkü o zaman enterpolasyon yapmak için bir değerler dizisi oluşturmanız gerekir.

Daha Scala benzeri bir çözüm, hata mesajının birleştirilmesini geciktirmek için bir thunk veya küme kullanmaktır. Buna iyi bir örnek Lift'in logger'ı

Log.scala Slf4jLog.scala

Bu şöyle görünür:

class Log4JLogger(val logger: Logger) extends LiftLogger {
  override def trace(msg: => AnyRef) = if (isTraceEnabled) logger.trace(msg)
}

Msg'nin isimle çağrı olduğunu ve isTraceEnabled doğru olmadığı sürece değerlendirilmeyeceğini unutmayın, bu nedenle güzel bir mesaj dizesi oluşturmanın maliyeti yoktur. Bu, slf4j'nin hata mesajının ayrıştırılmasını gerektiren enterpolasyon mekanizması etrafında çalışır. Bu modelle, hata mesajına istediğiniz sayıda değeri enterpolasyon yapabilirsiniz.

Bu Log4JLogger'ı sınıfınıza karıştıran ayrı bir özelliğiniz varsa, bunu yapabilirsiniz

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

onun yerine

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

Logula kullanma

Aslında Eugene önerisi takip ve denedim ve beceriksiz bir tasarıma sahiptir ve (gibi sabit alamadım hatalar, tabi ki öğrendim bu bir ). Bakımlı görünmüyor ve Scala 2.10'u desteklemiyor .

Slf4s + slf4j-simple kullanın

Temel faydaları:

• En yeni Scala 2.10'u destekler (bugüne kadar M7)
• Yapılandırma çok yönlü ancak daha basit olamazdı. O ile bitti sistem özelliklerine gibi bir şey ekleyerek ya ayarlayabilirsiniz, -Dorg.slf4j.simplelogger.defaultlog=tracekomut dosyanızda yürütme komutu veya kodlamalısınız: System.setProperty("org.slf4j.simplelogger.defaultlog", "trace"). Değersiz yapılandırma dosyalarını yönetmeye gerek yok!
• IDE'lerle güzel uyum sağlar. Örnek IDEA belirli çalışma yapılandırmasında "iz" Günlük düzeyini ayarlamak için için sadece gidin Run/Debug Configurationsve eklemek -Dorg.slf4j.simplelogger.defaultlog=traceiçin VM options.
• Kolay kurulum: bu cevabın alt kısmındaki bağımlılıkları bırakın

Maven ile çalıştırmanız için ihtiyacınız olan şey:

<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>

Bu bende nasıl Scala Günlüğü benim için çalışma:

Bunu şunun içine koy build.sbt:

libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.7.2",
libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3"

Sonra, bir yaptıktan sonra sbt update, bu kolay bir günlük mesajı yazdırır:

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

Oynat kullanıyorsanız yapabilirsiniz elbette sadece import play.api.Loggerlog mesajları yazmak için: Logger.debug("Hi").

Daha fazla bilgi için dokümanlara bakın .

Ben iş formunun bir Biti çekti Loggingait özelliği scalaxve ayrıca entegre bir özellik yarattı MessageFormat-basedkütüphane.

Sonra şeyler şöyle görünür:

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

Yaklaşımı seviyoruz.

Uygulama:

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))  
}

SLF4J + Logback classic kullanıyorum ve şu şekilde uyguluyorum:

trait Logging {
  lazy val logger = LoggerFactory.getLogger(getClass)

  implicit def logging2Logger(anything: Logging): Logger = anything.logger
}

Sonra tarzınıza daha uygun olanı kullanabilirsiniz:

class X with Logging {
    logger.debug("foo")
    debug("bar")
}

ancak bu yaklaşım elbette her sınıf örneği için bir logger örneği kullanır.

Scalax kütüphanesine bir göz atmalısınız: http://scalax.scalaforge.org/ Bu kütüphanede, arka uç olarak sl4j kullanan bir Günlük kaydı özelliği vardır. Bu özelliği kullanarak kolayca giriş yapabilirsiniz (sadece özelliği devralan sınıftaki günlükçü alanını kullanın).

Writer, MonoidVe bir Monaduygulama.

Henüz denemedim, ancak Configgy hem yapılandırma hem de günlük kaydı için umut verici görünüyor:

http://github.com/robey/configgy/tree/master

Hızlı ve kolay formlar.

Scala 2.10 ve üstü:

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

Ve build.sbt:

libraryDependencies += "com.typesafe" %% "scalalogging-slf4j" % "1.1.0"

Scala 2.11+ ve daha yenisi:

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

Ve build.sbt:

libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.1.0"

Bir süre slf4s ve logula kullandıktan sonra, slf4j logladysarma basit bir günlük kaydı özelliği yazdı .

Genel vakaları (temel dize, basit biçimlendirme) önemsiz hale getiren ve kazan plakasını biçimlendirmeyi önleyen Python'un günlük kütüphanesine benzer bir API sunar.

http://github.com/dln/loglady/

Bana böyle bir sözdizimi getiren basit scala sarıcı ile bir tür java logger, sl4j kullanarak çok uygun buluyorum

val #! = new Logger(..) // somewhere deep in dsl.logging.

object User with dsl.logging {

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

}

Bence java kanıtlanmış günlükleme çerçeveleri ve scala'nın fantezi sözdiziminin çok yararlı karışımı.