La journalisation en Scala

Question

Ce qui est une bonne façon de faire de l'ouverture d'un Scala application? Quelque chose qui est compatible avec le langage de la philosophie, de ne pas encombrer le code, et il est peu d'entretien et discrète. Voici une exigence de base de la liste:

• simple
• ne pas encombrer le code. Scala est idéal pour sa brièveté. Je ne veux pas la moitié de mon code pour être des instructions de journalisation
• format de journal peuvent être modifiés pour s'adapter au reste de mon entreprise journaux et les logiciels de surveillance
• prend en charge les niveaux de journalisation (c'est à dire de débogage, de trace, d'erreur)
• pouvez ouvrir une session sur le disque ainsi que d'autres destinations (par exemple douille, console, etc...)
• configuration minimale, le cas échéant
• œuvres dans des contenants (c'est à dire, serveur web)
• (facultatif, mais bien d'avoir) vient soit dans le cadre de la langue ou comme un artefact maven, donc je n'ai pas de pirater mes construit à l'utiliser

Je sais que je peux utiliser la journalisation Java des solutions, mais ils ne parviennent pas à au moins deux de ce qui précède, à savoir l'encombrement et de la configuration.

Merci pour vos réponses.

Answer 1

Tous les de la Scala de journalisation de bibliothèques en avril 2014 sont des wrappers de l'un des trois journalisation Java cadres: slf4j, log4j, et java.util.logging. Il n'y a presque pas de différence entre les bibliothèques en termes de méthodes de journalisation. Ils fournissent une sorte de log objet auquel vous pouvez appeler info(...), debug(...), etc. Je ne suis pas un grand fan de slf4j, mais il semble maintenant être le prédominant de journalisation.

Les principales différences sont la façon dont les bûcherons sont configurés.

slf4j wrappers

Voici la description de SLF4J:

La Journalisation Simple Façade pour Java ou (SLF4J) sert comme une simple façade ou à l'abstraction pour l'enregistrement différents cadres, par exemple, java.util.la journalisation, log4j et logback, permettant à l'utilisateur de brancher l'enregistrement souhaité cadre au moment du déploiement.

La capacité de changement sous-jacent journal de la bibliothèque au moment du déploiement apporte caractéristique unique à l'ensemble de slf4j de la famille de bûcherons, vous devez être conscient de.

Tout d'abord, est le "classpath" configuration de l'approche. La façon slf4j sait qui sous-tendent la journalisation de la bibliothèque que vous utilisez est par chargement d'une classe par un certain nom. J'ai eu des problèmes en ce qui slf4j de ne pas reconnaître mon enregistreur lorsque le chargeur de classe a été personnalisé.

Deuxièmement, parce que le "simple façade" essaie d'être le dénominateur commun, c'est uniquement limité à de véritables appels du journal. En d'autres termes, la configuration ne peut pas être fait via le code.

Dans un grand projet, il pourrait être pratique pour être en mesure de contrôler le comportement d'enregistrement de dépendances transitives si tout le monde s'slf4j.

Scala De Journalisation

Scala de Journalisation est écrit par Heiko Seeberger comme un successeur à son slf4s. Il utilise une macro pour élargir les appels si l'expression à éviter potentiellement coûteux journal d'appel.

Scala enregistrement est une pratique et performant bibliothèque de journalisation d'emballage de journalisation des bibliothèques comme SLF4J et éventuellement d'autres.

logback

logback, écrit par Ceki Gülcü qui a aussi écrit SLF4J et log4j, est la norme de mise en œuvre de SLF4J. Il y a une page appelée Raisons de préférer logback plus de log4j. Les points clés semble être qu'il joue bien à côté serveur.

Grisonnant SLF4J

Brian Battant également écrit un SLF4J wrapper appelé Grisonnant SLF4J.

Le Grisonnant SLF4J paquet fournit un très mince Scala-friendly couche sur le dessus de la SLF4J (Journalisation Simple Façade pour Java) de l'API. Il est publié sous une licence BSD.

AVSL (Très Simple Logger)

Comme backend pour SLF4J API, Brian Battant a écrit AVSL.

"AVSL" signifie "Un Très Simple Logger", et AVSL s'efforce pour des raisons de simplicité de plusieurs façons.

• AVSL est simple à configurer, à l'aide d'un non-XML, INI-style de fichier de configuration qui rappelle le Python module de journalisation de la configuration. Ce simple fichier de configuration est plus facile de lire et de modifier que les fichiers de configuration XML utilisé par la journalisation des frameworks tels que Logback. (Car je n'aime pas les fichiers de configuration XML, c'est la grosse victoire pour moi.)
• AVSL est un poids léger de journalisation. Il est destiné à être utilisé principalement dans les programmes autonomes, pas d'applications d'entreprise. Il peut bien fonctionner pour votre application d'entreprise, bien sûr; mais, si cela ne fonctionne pas, vous pouvez facilement passer à autre chose.
• Le message par défaut formateur utilise une méthode plus simple, plus compact de la syntaxe de Java est SimpleDateFormat, en s'appuyant sur strftime-comme s'échappe.

loglady

loglady qui est sorti en 2012 est une mince wrapper autour de SLF4J, en fournissant une API simple similaire à Python module de journalisation. La principale caractéristique des listes:

• Aucune configuration

log4j wrappers

Logula

Coda Hale est Logula utilisé pour être bon, mais maintenant abandonné.

Logula est un Scala bibliothèque qui fournit un journal de sane format de sortie et facile à utiliser mixin pour l'ajout de la journalisation de votre code.

C'est un mince avant la fin de l'log4j 1.2 parce que java.util.l'enregistrement est une douleur dans le cou à traiter.

La configuration se fait via le code au lieu d'un fichier de configuration, ce qui signifie que je peux changer le niveau de journal d' TRACE si l'utilisateur sélectionne option verbose.

java.util.la journalisation des wrappers

configgy est parti

configgy, probablement encore utilisé par beaucoup, est désormais officiellement déclarée obsolète.

ce que twitter?

Maintenant que configgy est allé, ce que twitter? Util d'enregistrement.

Util-la journalisation est un petit wrapper autour de java builtin la journalisation pour le rendre plus scala-friendly.

Il n'y a pas de fichier de config car il est chargé de la scala de fichier à l'aide de l'autruche, je ne comprends pas tout mais qu'est ce qu'il dit.

Divers

zéro-journal

zéro-journal est sorti en 2012. Conçu pour être rapide et simple. Coût pour les personnes handicapées les journaux peuvent être exactement zéro. (Je n'ai jamais utilisé ce donc je n'ai pas une opinion sur celui-ci)

Answer 2

Avec Scala 2.10+ Envisager ScalaLogging par Typesafe. Utilise des macros pour offrir une très propre API

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

Citant leur wiki:

Heureusement Scala macros peuvent être utilisés pour rendre notre vie plus facile: ScalaLogging offre la classe Logger avec un léger méthodes de journalisation qui sera élargi au-dessus de l'idiome. Donc, tout ce que nous avons à écrire, c'est:

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

Après la macro a été appliqué, le code aura été transformé en le ci-dessus décrite idiome.

En outre ScalaLogging offre le trait Logging qui offre idéalement une Logger instance initialisée avec le nom de la classe mixte en:

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

Answer 3

À l'aide de slf4j et un wrapper est agréable, mais l'utilisation de il est construit dans l'interpolation des pauses vers le bas lorsque vous avez plus de deux valeurs à interpoler, car alors vous avez besoin pour créer un Tableau de valeurs à interpoler.

Plus de Scala comme solution consiste à utiliser un thunk de clusters ou de retarder la concaténation du message d'erreur. Un bon exemple de ceci est l'Ascenseur de l'enregistreur

Journal.scala Slf4jLog.scala

Qui ressemble à ceci:

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

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

Si vous avez un trait de caractère qui mélange ce Log4JLogger dans votre classe, vous pouvez le 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))

Answer 4

N'utilisez pas de Logula

En fait, j'ai suivi la recommandation de Eugene et il a essayé et a découvert qu'il est maladroit de configuration et est soumis à des bugs, qui ne se fixe (comme cette une). Il n'a pas l'air d'être bien entretenu et il ne prend pas en charge Scala 2.10.

Utilisation slf4s + slf4j-simple

Avantages clés:

• Prend en charge les dernières Scala 2.10 (à ce jour c'est M7)
• La Configuration est polyvalent, mais ne pouvait pas être plus simple. C'est fait avec le système de propriétésque vous pouvez définir, soit en ajoutant quelque chose comme -Dorg.slf4j.simplelogger.defaultlog=trace à la commande de l'exécution ou de coder en dur dans le script: System.setProperty("org.slf4j.simplelogger.defaultlog", "trace"). Pas besoin de gérer trash fichiers de configuration!
• S'intègre parfaitement avec IDEs. Par exemple, pour définir le niveau de journalisation de "trace" dans une configuration d'exécution dans l'IDÉE il suffit d'aller à Run/Debug Configurations et ajouter -Dorg.slf4j.simplelogger.defaultlog=trace de VM options.
• Installation facile: il suffit de déposer dans les dépendances à partir du bas de cette réponse

Voici ce que vous devez être en cours d'exécution 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>

Answer 5

J'ai tiré un peu de travail formulaire de l' Logging trait d' scalax, et a créé un trait de caractère qui a également intégré un MessageFormat-based bibliothèque.

Puis des trucs genre de ressemble à ceci:

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

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

Mise en œuvre:

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