Quelle est la bonne façon de se connecter dans une application Scala? Quelque chose qui est cohérent avec la philosophie du langage, n'encombre pas le code, nécessite peu d'entretien et est discret. Voici une liste d'exigences de base:

• Facile
• n'encombre pas le code. Scala est excellent pour sa brièveté. Je ne veux pas que la moitié de mon code consigne des instructions
• le format du journal peut être modifié pour s'adapter au reste de mes journaux d'entreprise et de mon logiciel de surveillance
• prend en charge les niveaux de journalisation (c'est-à-dire débogage, trace, erreur)
• peut se connecter au disque ainsi qu'à d'autres destinations (c'est-à-dire socket, console, etc.)
• configuration minimale, le cas échéant
• fonctionne dans des conteneurs (c.-à-d. serveur Web)
• (facultatif, mais agréable à avoir) vient soit dans le cadre du langage, soit comme un artefact maven, donc je n'ai pas à pirater mes builds pour l'utiliser

Je sais que je peux utiliser les solutions de journalisation Java existantes, mais elles échouent sur au moins deux des éléments ci-dessus, à savoir l'encombrement et la configuration.

Merci pour vos réponses.

wrappers slf4j

La plupart des bibliothèques de journalisation de Scala ont été des wrappers autour d'un framework de journalisation Java (slf4j, log4j, etc.), mais en mars 2015, les bibliothèques de journaux survivantes sont toutes slf4j. Ces bibliothèques de journaux fournissent une sorte d' logobjet auquel vous pouvez appeler info(...), debug(...)etc. Je ne suis pas un grand fan de slf4j, mais il semble maintenant être le cadre de journalisation prédominant. Voici la description de SLF4J :

La façade de journalisation simple pour Java ou (SLF4J) sert de simple façade ou abstraction pour divers cadres de journalisation, par exemple java.util.logging, log4j et logback, permettant à l'utilisateur final de se connecter au cadre de journalisation souhaité au moment du déploiement.

La possibilité de modifier la bibliothèque de journaux sous-jacente au moment du déploiement apporte une caractéristique unique à toute la famille de loggers slf4j, dont vous devez être conscient:

1. classpath comme approche de configuration . La façon dont slf4j sait quelle bibliothèque de journalisation sous-jacente vous utilisez consiste à charger une classe par un nom. J'ai eu des problèmes dans lesquels slf4j ne reconnaissait pas mon enregistreur lorsque le chargeur de classe était personnalisé.
2. Parce que la façade simple essaie d'être le dénominateur commun, elle est limitée uniquement aux appels de journaux réels. En d'autres termes, la configuration ne peut pas se faire via le code.

Dans un grand projet, il pourrait en fait être pratique de pouvoir contrôler le comportement de journalisation des dépendances transitives si tout le monde utilisait slf4j.

Journalisation Scala

Scala Logging est écrit par Heiko Seeberger comme successeur de ses slf4s . Il utilise une macro pour développer les appels dans l'expression if afin d'éviter un appel de journal potentiellement coûteux.

Scala Logging est une bibliothèque de journalisation pratique et performante qui englobe des bibliothèques de journalisation comme SLF4J et potentiellement d'autres.

Enregistreurs historiques

• Logula , un wrapper Log4J écrit par Coda Hale. J'aimais bien celui-ci, mais maintenant il est abandonné.
• configgy , un wrapper java.util.logging qui était populaire dans les premiers jours de Scala. Maintenant abandonné.

Avec Scala 2.10+, pensez à ScalaLogging de Typesafe. Utilise des macros pour fournir une API très propre

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

Citant leur wiki:

Heureusement, les macros Scala peuvent être utilisées pour nous faciliter la vie: ScalaLogging propose la classe Loggeravec des méthodes de journalisation légères qui seront étendues à l'idiome ci-dessus. Donc, tout ce que nous avons à écrire est:

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

Une fois la macro appliquée, le code aura été transformé dans l'idiome décrit ci-dessus.

De plus, ScalaLogging offre le trait Loggingqui fournit commodément une Loggerinstance initialisée avec le nom de la classe mélangée dans:

import com.typesafe.scalalogging.slf4j.LazyLogging

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

Utiliser slf4j et un wrapper est bien mais l'utilisation de son interpolation intégrée se décompose lorsque vous avez plus de deux valeurs à interpoler, car vous devez créer un tableau de valeurs à interpoler.

Une solution plus Scala consiste à utiliser un thunk ou un cluster pour retarder la concaténation du message d'erreur. Un bon exemple de ceci est l'enregistreur de Lift

Log.scala Slf4jLog.scala

Ce qui ressemble à ceci:

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

Notez que msg est un appel par nom et ne sera pas évalué à moins que isTraceEnabled soit vrai, il n'y a donc aucun coût à générer une belle chaîne de message. Cela fonctionne autour du mécanisme d'interpolation de slf4j qui nécessite l'analyse du message d'erreur. Avec ce modèle, vous pouvez interpoler n'importe quel nombre de valeurs dans le message d'erreur.

Si vous avez un trait distinct qui mélange ce Log4JLogger dans votre classe, vous pouvez faire

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

au lieu de

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

N'utilisez pas Logula

J'ai en fait suivi la recommandation d'Eugene et l'ai essayé et j'ai découvert qu'il avait une configuration maladroite et qu'il était soumis à des bogues, qui ne sont pas corrigés (comme celui-ci ). Il ne semble pas être bien entretenu et il ne prend pas en charge Scala 2.10 .

Utilisez slf4s + slf4j-simple

Avantages clés:

• Prend en charge la dernière Scala 2.10 (à ce jour, c'est M7)
• La configuration est polyvalente mais ne pourrait pas être plus simple. Il est fait avec les propriétés du système , que vous pouvez définir soit en ajoutant quelque chose comme -Dorg.slf4j.simplelogger.defaultlog=traceà commander ou hardcode exécution dans votre script: System.setProperty("org.slf4j.simplelogger.defaultlog", "trace"). Pas besoin de gérer les fichiers de configuration trash!
• Convient bien aux IDE. Par exemple, pour définir le niveau de journalisation sur «trace» dans une configuration d'exécution spécifique dans IDEA, il suffit d'aller sur Run/Debug Configurationset d'ajouter -Dorg.slf4j.simplelogger.defaultlog=traceà VM options.
• Configuration facile: déposez simplement les dépendances à partir du bas de cette réponse

Voici ce dont vous avez besoin pour l'exécuter avec 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>

Voici comment j'ai fait fonctionner Scala Logging pour moi:

Mettez ceci dans votre build.sbt:

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

Ensuite, après avoir fait une sbt update, ceci imprime un message de journal convivial:

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

Si vous utilisez Play, vous pouvez bien sûr simplement import play.api.Loggerpour écrire des messages du journal: Logger.debug("Hi").

Consultez la documentation pour plus d'informations.

J'ai tiré un peu de travail du Loggingtrait de scalax, et créé un trait qui a également intégré une MessageFormat-basedbibliothèque.

Ensuite, les choses ressemblent à ceci:

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

Nous aimons l'approche jusqu'à présent.

La mise en oeuvre:

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

J'utilise SLF4J + Logback classic et je l'applique comme ceci:

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

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

Ensuite, vous pouvez l'utiliser selon ce qui correspond le mieux à votre style:

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

mais cette approche utilise bien sûr une instance de journalisation par instance de classe.

Vous devriez jeter un œil à la bibliothèque scalax: http://scalax.scalaforge.org/ Dans cette bibliothèque, il y a un trait Logging, utilisant sl4j comme backend. En utilisant ce trait, vous pouvez vous connecter assez facilement (utilisez simplement le champ logger dans la classe héritant du trait).

Writer, Monoidet une Monadmise en œuvre.

Je ne l'ai pas encore essayé, mais Configgy semble prometteur pour la configuration et la journalisation:

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

Formulaires rapides et faciles.

Scala 2.10 et plus ancien:

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

Et build.sbt:

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

Scala 2.11+ et plus récent:

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

Et build.sbt:

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

Après avoir utilisé slf4s et logula pendant un certain temps, j'ai écrit loglady, un trait de journalisation simple enveloppant slf4j.

Il propose une API similaire à celle de la bibliothèque de journalisation de Python, ce qui rend les cas courants (chaîne de base, formatage simple) triviaux et évite le formatage standard.

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

Je trouve très pratique d'utiliser une sorte de java logger, sl4j par exemple, avec un simple wrapper scala, ce qui m'apporte une telle syntaxe

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

object User with dsl.logging {

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

}

À mon avis, un mélange très utile de frameworks de journalisation éprouvés en Java et de la syntaxe sophistiquée de scala.