Apa cara yang baik untuk melakukan login dalam aplikasi Scala? Sesuatu yang konsisten dengan filosofi bahasa, tidak mengacaukan kode, dan pemeliharaannya rendah dan tidak mengganggu. Berikut daftar persyaratan dasar:

• sederhana
• tidak mengacaukan kode. Scala sangat bagus untuk singkatnya. Saya tidak ingin setengah dari kode saya menjadi pernyataan logging
• format log dapat diubah agar sesuai dengan sisa log perusahaan saya dan perangkat lunak pemantauan
• mendukung level logging (mis. debug, jejak, kesalahan)
• dapat masuk ke disk serta tujuan lain (mis. soket, konsol, dll.)
• konfigurasi minimum, jika ada
• bekerja dalam wadah (mis., server web)
• (opsional, tetapi menyenangkan untuk dimiliki) hadir sebagai bagian dari bahasa atau sebagai artefak pakar, jadi saya tidak perlu meretas bangunan saya untuk menggunakannya

Saya tahu saya bisa menggunakan solusi logging Java yang ada, tetapi mereka gagal pada setidaknya dua di atas, yaitu kekacauan dan konfigurasi.

Terima kasih atas balasan Anda.

pembungkus slf4j

Sebagian besar pustaka logging Scala memiliki beberapa pembungkus di sekitar kerangka kerja logging Java (slf4j, log4j dll), tetapi pada Maret 2015, pustaka log yang bertahan semua slf4j. Pustaka log ini menyediakan semacam logobjek yang dapat Anda panggil info(...), debug(...)dll. Saya bukan penggemar slf4j, tetapi sekarang tampaknya merupakan kerangka kerja logging yang dominan. Berikut deskripsi SLF4J :

Simple Logging Facade for Java atau (SLF4J) berfungsi sebagai fasad atau abstraksi sederhana untuk berbagai kerangka kerja logging, misalnya java.util.logging, log4j dan logback, memungkinkan pengguna akhir untuk memasukkan kerangka logging yang diinginkan pada waktu penempatan.

Kemampuan untuk mengubah pustaka log yang mendasarinya pada waktu penyebaran menghadirkan karakteristik unik bagi seluruh keluarga penebang slf4j, yang perlu Anda perhatikan:

1. classpath sebagai pendekatan konfigurasi . Cara slf4j mengetahui pustaka logging mana yang Anda gunakan adalah dengan memuat kelas dengan beberapa nama. Saya punya masalah di mana slf4j tidak mengenali logger saya ketika classloader dikustomisasi.
2. Karena fasad sederhana mencoba menjadi penyebut yang umum, ia hanya terbatas pada panggilan log yang sebenarnya. Dengan kata lain, konfigurasi tidak dapat dilakukan melalui kode.

Dalam proyek besar, sebenarnya bisa nyaman untuk dapat mengendalikan perilaku logging dari dependensi transitif jika semua orang menggunakan slf4j.

Penebangan Scala

Scala Logging ditulis oleh Heiko Seeberger sebagai penerus slf4s- nya . Ini menggunakan makro untuk memperluas panggilan ke ekspresi jika untuk menghindari panggilan log berpotensi mahal.

Scala Logging adalah perpustakaan pencatatan log yang nyaman dan performan yang membungkus perpustakaan logging seperti SLF4J dan yang lainnya.

Penebang historis

• Logula , pembungkus Log4J yang ditulis oleh Coda Hale. Dulu suka yang ini, tapi sekarang sudah ditinggalkan.
• configgy , pembungkus java.util.logging yang dulu populer di hari-hari awal Scala. Sekarang ditinggalkan.

Dengan Scala 2.10+ Pertimbangkan ScalaLogging oleh Typesafe. Menggunakan makro untuk memberikan API yang sangat bersih

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

Mengutip dari wiki mereka:

Untungnya macro Scala dapat digunakan untuk membuat hidup kita lebih mudah: ScalaLogging menawarkan kelas Loggerdengan metode logging ringan yang akan diperluas ke idiom di atas. Jadi yang harus kita tulis adalah:

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

Setelah makro diterapkan, kode akan diubah menjadi idiom yang dijelaskan di atas.

Selain itu ScalaLogging menawarkan sifat Loggingyang dengan mudah memberikan Loggercontoh diinisialisasi dengan nama kelas yang dicampur menjadi:

import com.typesafe.scalalogging.slf4j.LazyLogging

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

Menggunakan slf4j dan pembungkus bagus tetapi penggunaan itu dibangun di interpolasi rusak ketika Anda memiliki lebih dari dua nilai untuk interpolasi, sejak itu Anda perlu membuat Array nilai untuk interpolasi.

Solusi yang lebih mirip Scala adalah dengan menggunakan thunk atau cluster untuk menunda penyatuan pesan kesalahan. Contoh yang bagus untuk hal ini adalah Lift's logger

Log.scala Slf4jLog.scala

Yang terlihat seperti ini:

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

Perhatikan bahwa msg adalah nama panggilan dan tidak akan dievaluasi kecuali isTraceEnabled benar sehingga tidak ada biaya dalam menghasilkan string pesan yang bagus. Ini bekerja di sekitar mekanisme interpolasi slf4j yang membutuhkan parsing pesan kesalahan. Dengan model ini, Anda dapat menginterpolasi sejumlah nilai ke dalam pesan kesalahan.

Jika Anda memiliki sifat terpisah yang mencampur Log4JLogger ini ke dalam kelas Anda, maka Anda bisa melakukannya

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

dari pada

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

Jangan gunakan Logula

Saya sebenarnya telah mengikuti rekomendasi dari Eugene dan mencobanya dan menemukan bahwa ia memiliki konfigurasi yang canggung dan mengalami bug, yang tidak diperbaiki (seperti ini ). Itu tidak terlihat terpelihara dengan baik dan tidak mendukung Scala 2.10 .

Gunakan slf4s + slf4j-simple

Kunci Keuntungan:

• Mendukung Scala 2.10 terbaru (sampai saat ini M7)
• Konfigurasi itu serbaguna tetapi tidak bisa lebih sederhana. Ini dilakukan dengan properti sistem , yang dapat Anda atur dengan menambahkan sesuatu seperti -Dorg.slf4j.simplelogger.defaultlog=traceke perintah eksekusi atau hardcode di skrip Anda:System.setProperty("org.slf4j.simplelogger.defaultlog", "trace") . Tidak perlu mengelola file konfigurasi sampah!
• Cocok dengan IDE. Misalnya untuk mengatur tingkat penebangan untuk "jejak" dalam konfigurasi tertentu dijalankan di IDEA hanya pergi ke Run/Debug Configurationsdan menambahkan -Dorg.slf4j.simplelogger.defaultlog=traceke VM options.
• Pengaturan mudah: cukup masukkan dependensi dari bawah jawaban ini

Inilah yang Anda perlukan untuk menjalankannya dengan Maven:

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

Beginilah cara saya mendapatkan Scala Logging bekerja untuk saya:

Letakkan ini di build.sbt:

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

Kemudian, setelah melakukan sbt update, ini mencetak pesan log ramah:

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

Jika Anda menggunakan Play, tentu saja Anda hanya import play.api.Loggerdapat menulis pesan log:Logger.debug("Hi") .

Lihat dokumen untuk info lebih lanjut.

Saya menarik sedikit pekerjaan dari Loggingsifat itu scalax, dan menciptakan sifat yang juga mengintegrasikan MessageFormat-basedperpustakaan.

Maka hal-hal seperti ini terlihat seperti ini:

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

Kami menyukai pendekatan sejauh ini.

Penerapan:

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

Saya menggunakan SLF4J + Logback klasik dan menerapkannya seperti ini:

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

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

Maka Anda dapat menggunakannya mana yang lebih cocok dengan gaya Anda:

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

tetapi pendekatan ini tentu saja menggunakan instance logger per instance kelas.

Anda harus melihat pada perpustakaan scalax: http://scalax.scalaforge.org/ Di perpustakaan ini, ada sifat Logging, menggunakan sl4j sebagai backend. Dengan menggunakan sifat ini, Anda bisa login dengan mudah (cukup gunakan bidang logger di kelas yang mewarisi sifat itu).

Writer, Monoiddan Monadimplementasi.

Belum mencobanya, tetapi Configgy tampak menjanjikan untuk konfigurasi dan masuk log:

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

Formulir cepat dan mudah.

Scala 2.10 dan lebih lama:

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

Dan build.sbt:

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

Scala 2.11+ dan yang lebih baru:

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

Dan build.sbt:

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

Setelah menggunakan slf4s dan logula untuk sementara waktu, saya menulis loglady, slf4j pembungkus sifat logging sederhana.

Ini menawarkan API yang mirip dengan perpustakaan logging Python, yang membuat kasus umum (string dasar, pemformatan sederhana) sepele dan menghindari memformat boilerplate.

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

Saya merasa sangat nyaman menggunakan beberapa jenis java logger, sl4j misalnya, dengan pembungkus scala sederhana, yang membawa saya sintaksis seperti

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

object User with dsl.logging {

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

}

Menurut pendapat saya sangat berguna mixin dari kerangka kerja logging java terbukti dan sintaksis mewah scala.