Cách tốt để đăng nhập vào ứng dụng Scala là gì? Một cái gì đó phù hợp với triết lý ngôn ngữ, không làm lộn xộn mã, và ít bảo trì và không phô trương. Đây là danh sách yêu cầu cơ bản:

• đơn giản
• không làm lộn xộn mã. Scala là tuyệt vời cho sự ngắn gọn của nó. Tôi không muốn một nửa mã của mình được ghi nhật ký
• định dạng nhật ký có thể được thay đổi để phù hợp với phần còn lại của nhật ký doanh nghiệp và phần mềm giám sát của tôi
• hỗ trợ các mức ghi nhật ký (tức là gỡ lỗi, theo dõi, lỗi)
• có thể đăng nhập vào đĩa cũng như các điểm đến khác (ví dụ: socket, console, v.v.)
• cấu hình tối thiểu, nếu có
• hoạt động trong các thùng chứa (tức là máy chủ web)
• (tùy chọn, nhưng rất tốt để có) là một phần của ngôn ngữ hoặc là một tạo tác maven, vì vậy tôi không phải hack các bản dựng của mình để sử dụng nó

Tôi biết tôi có thể sử dụng các giải pháp ghi nhật ký Java hiện có, nhưng chúng thất bại ở ít nhất hai trong số trên, đó là sự lộn xộn và cấu hình.

Cảm ơn bạn đã trả lời.

giấy gói slf4j

Hầu hết các thư viện ghi nhật ký của Scala là một số trình bao bọc xung quanh khung ghi nhật ký Java (slf4j, log4j, v.v.), nhưng kể từ tháng 3 năm 2015, các thư viện nhật ký còn tồn tại đều là slf4j. Các thư viện nhật ký này cung cấp một số loại logđối tượng mà bạn có thể gọi info(...), debug(...)v.v. Tôi không phải là một fan hâm mộ lớn của slf4j, nhưng giờ đây nó dường như là khung ghi nhật ký chiếm ưu thế. Dưới đây là mô tả của SLF4J :

Mặt tiền ghi nhật ký đơn giản cho Java hoặc (SLF4J) đóng vai trò là mặt tiền đơn giản hoặc trừu tượng hóa cho các khung ghi nhật ký khác nhau, ví dụ java.util.logging, log4j và logback, cho phép người dùng cuối cắm vào khung ghi nhật ký mong muốn khi triển khai.

Khả năng thay đổi thư viện nhật ký cơ bản tại thời điểm triển khai mang lại đặc tính duy nhất cho toàn bộ họ logger slf4j, mà bạn cần lưu ý:

1. classpath như cách tiếp cận cấu hình . Cách slf4j biết thư viện ghi nhật ký cơ bản nào bạn đang sử dụng bằng cách tải một lớp theo tên nào đó. Tôi đã có vấn đề trong đó slf4j không nhận ra logger của tôi khi trình nạp lớp được tùy chỉnh.
2. Bởi vì mặt tiền đơn giản cố gắng trở thành mẫu số chung, nên nó chỉ giới hạn ở các cuộc gọi nhật ký thực tế. Nói cách khác, cấu hình không thể được thực hiện thông qua mã.

Trong một dự án lớn, thực sự có thể thuận tiện để có thể kiểm soát hành vi ghi nhật ký của các phụ thuộc bắc cầu nếu mọi người sử dụng slf4j.

Ghi nhật ký Scala

Scala Logging được viết bởi Heiko Seeberger như một sự kế thừa cho slf4s của mình . Nó sử dụng macro để mở rộng các cuộc gọi thành biểu thức if để tránh cuộc gọi log đắt tiền.

Scala Logging là một thư viện ghi nhật ký tiện lợi và hiệu quả bao bọc các thư viện ghi nhật ký như SLF4J và các tiềm năng khác.

Khai thác lịch sử

• Logula , một trình bao bọc Log4J được viết bởi Coda Hale. Đã từng thích cái này, nhưng giờ nó đã bị bỏ rơi.
• configgy , một trình bao bọc java.util.logging đã từng phổ biến trong những ngày đầu của Scala. Bây giờ bị bỏ rơi.

Với Scala 2.10+ Hãy xem xét ScalaLogging theo Formsafe. Sử dụng macro để cung cấp API rất sạch

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

Trích dẫn từ wiki của họ:

May mắn thay, các macro Scala có thể được sử dụng để làm cho cuộc sống của chúng ta dễ dàng hơn: ScalaLogging cung cấp lớp Loggervới các phương thức ghi nhật ký nhẹ sẽ được mở rộng thành thành ngữ trên. Vì vậy, tất cả chúng ta phải viết là:

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

Sau khi macro được áp dụng, mã sẽ được chuyển thành thành ngữ được mô tả ở trên.

Ngoài ra, ScalaLogging cung cấp đặc điểm Loggingcung cấp một Loggerthể hiện được khởi tạo một cách thuận tiện với tên của lớp được trộn vào:

import com.typesafe.scalalogging.slf4j.LazyLogging

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

Sử dụng slf4j và trình bao bọc là tốt nhưng việc sử dụng phép nội suy được xây dựng bị phá vỡ khi bạn có nhiều hơn hai giá trị để nội suy, do đó bạn cần tạo một mảng các giá trị để nội suy.

Một giải pháp giống Scala hơn là sử dụng một thunk hoặc cluster để trì hoãn việc ghép thông báo lỗi. Một ví dụ điển hình của việc này là logger của thang máy

Log.scala Slf4jLog.scala

Trông như thế này:

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

Lưu ý rằng tin nhắn là một cuộc gọi theo tên và sẽ không được đánh giá trừ khi isTraceEnables là đúng vì vậy không có chi phí trong việc tạo ra một chuỗi tin nhắn đẹp. Điều này hoạt động xung quanh cơ chế nội suy của slf4j yêu cầu phân tích thông báo lỗi. Với mô hình này, bạn có thể nội suy bất kỳ số lượng giá trị nào vào thông báo lỗi.

Nếu bạn có một đặc điểm riêng biệt trộn Log4JLogger này vào lớp của bạn, thì bạn có thể làm

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

thay vì

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

Đừng sử dụng Logula

Tôi thực sự đã làm theo khuyến nghị của Eugene và đã thử nó và phát hiện ra rằng nó có cấu hình vụng về và bị lỗi, không được sửa (chẳng hạn như cái này ). Nó không được duy trì tốt và nó không hỗ trợ Scala 2.10 .

Sử dụng slf4s + slf4j-đơn giản

Lợi ích chính:

• Hỗ trợ Scala 2.10 mới nhất (đến nay là M7)
• Cấu hình là linh hoạt nhưng không thể đơn giản hơn. Nó được thực hiện với các thuộc tính hệ thống , mà bạn có thể thiết lập bằng cách nối thêm một số thứ như -Dorg.slf4j.simplelogger.defaultlog=tracethực thi lệnh hoặc mã cứng trong tập lệnh của mình:System.setProperty("org.slf4j.simplelogger.defaultlog", "trace") . Không cần phải quản lý tập tin cấu hình rác!
• Phù hợp độc đáo với IDE. Chẳng hạn, để đặt mức ghi nhật ký thành "theo dõi" trong cấu hình chạy cụ thể trong IDEA, chỉ cần truy cập Run/Debug Configurationsvà thêm -Dorg.slf4j.simplelogger.defaultlog=tracevào VM options.
• Dễ dàng thiết lập: chỉ cần bỏ phần phụ thuộc từ cuối câu trả lời này

Đây là những gì bạn cần để chạy nó với 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>

Đây là cách tôi có Scala Logging làm việc cho tôi:

Đặt cái này trong build.sbt:

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

Sau đó, sau khi thực hiện sbt update, điều này sẽ in ra một thông điệp nhật ký thân thiện:

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

Nếu bạn đang sử dụng Play, tất nhiên bạn có thể chỉ cần import play.api.Loggerviết thông điệp tường trình : Logger.debug("Hi").

Xem tài liệu để biết thêm.

Tôi đã tạo ra một chút công việc tạo thành Loggingđặc điểm scalaxvà tạo ra một đặc điểm cũng tích hợp mộtMessageFormat-based thư viện.

Sau đó, những thứ trông như thế này:

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

Chúng tôi thích cách tiếp cận cho đến nay.

Thực hiện:

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

Tôi sử dụng SLF4J + Logback classic và áp dụng nó như thế này:

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

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

Sau đó, bạn có thể sử dụng nó phù hợp với phong cách của bạn hơn:

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

nhưng cách tiếp cận này tất nhiên sử dụng một thể hiện logger cho mỗi thể hiện của lớp.

Bạn nên xem thư viện scalax: http://scalax.scalaforge.org/ Trong thư viện này, có một đặc điểm Ghi nhật ký, sử dụng sl4j làm phụ trợ. Bằng cách sử dụng đặc điểm này, bạn có thể đăng nhập khá dễ dàng (chỉ cần sử dụng trường logger trong lớp kế thừa tính trạng).

Writer, MonoidVà Monadthực hiện.

Chưa thử, nhưng Configgy có vẻ hứa hẹn cho cả cấu hình và ghi nhật ký:

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

Hình thức nhanh chóng và dễ dàng.

Scala 2.10 trở lên:

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

Và build.sbt:

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

Scala 2.11+ và mới hơn:

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

Và build.sbt:

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

Sau khi sử dụng slf4s và logula một lúc, tôi đã viết loglady, một đặc điểm đăng nhập đơn giản bao gồm slf4j.

Nó cung cấp một API tương tự như thư viện ghi nhật ký của Python, làm cho các trường hợp phổ biến (chuỗi cơ bản, định dạng đơn giản) trở nên tầm thường và tránh định dạng soạn sẵn.

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

Tôi thấy rất thuận tiện khi sử dụng một số loại java logger, ví dụ sl4j, với trình bao bọc scala đơn giản, mang lại cho tôi cú pháp như vậy

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

object User with dsl.logging {

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

}

Theo ý kiến ​​của tôi, mixin rất hữu ích của các khung ghi nhật ký đã được chứng minh của java và cú pháp ưa thích của scala.