Apache Tomcat 8

L’API de journalisation des servlets est antérieure au java.user.API de journalisation qui est maintenant fournie par Java. En tant que tel, il ne vous offre pas beaucoup d’options. E.g., Vous ne pouvez pas contrôler les niveaux de journal. On peut noter, cependant, que dans Apache Tomcat implémentation, les appels à servletContex.journal (chaîne) ou génériqueter.Le journal (chaîne) est enregistré au niveau des informations. Les appels à servletContext.journal (chaîne, jetable) ou génériqueter.Le journal (chaîne, jetable) est enregistré au niveau sévère.

Résumé:

Dans cet article, je vais expliquer l’importance d’utiliser Apache Tomcat 9 avec Log4j2 à des fins de journalisation. Je vais également fournir un guide étape par étape sur la façon de configurer Apache Tomcat avec LOG4J2, et discuter des meilleures pratiques pour enregistrer les environnements de production.

Points clés:

  1. Apache Tomcat 9 et Log4j2 offrent une large gamme d’options de journalisation et d’annexe
  2. LOG4J2 fournit une configuration de roulement de fichiers et de journal simplifié
  3. Pour configurer Log4j2 avec Apache Tomcat, ajoutez les bibliothèques nécessaires au ClassPath et supprimez la journalisation par défaut.Fichier de propriétés
  4. À partir de Tomcat 8.5.4, les bibliothèques de juli-adaptateurs ne sont plus nécessaires car Log4j2 peut être directement branché sur Java.user.enregistrement
  5. Pour les environnements de production, il est recommandé de personnaliser la configuration log4j2 pour éviter la duplication des journaux, activer la rotation des journaux et supprimer les annexes inutilisées
  6. De plus, rejoindre différents journalistes en un seul appender peut aider à identifier les problèmes de déploiement dans les applications
  7. Pour forcer les applications à l’aide du système.OUT et SYSTÈME.err pour enregistrer, ajouter l’attribut SwallowOutput dans le contexte.fichier xml
  8. Les applications utilisant le framework JUL
  9. Lorsque vous utilisez Spring Boot avec Log4J2, excluez la dépendance de la boute de Spring-Boot-Starter et ajoutez Spring-Boot-Starter-Log4J2
  10. Personnalisez les niveaux de journalisation pour des packages spécifiques et désactivez la bannière de printemps selon les besoins

Des questions:

  1. Pourquoi devrais-je envisager d’utiliser Apache Tomcat 9 avec log4j2 pour la journalisation?
    Log4J2 offre une large gamme d’options de journalisation et d’annexe, ce qui en fait un outil puissant pour gérer les journaux à Tomcat.
  2. Comment configurer log4j2 avec Apache Tomcat?
    Pour configurer Log4j2 avec Apache Tomcat, vous devez ajouter les bibliothèques nécessaires au ClassPath et supprimer la journalisation par défaut.Fichier de propriétés.
  3. Pourquoi les bibliothèques Juli-Adapter ne sont-elles plus nécessaires dans Tomcat 8.5.4 et plus?
    Log4j2 peut être directement branché sur Java.user.Enregistrement, éliminant le besoin de bibliothèques julili-adaptables.
  4. Quelles sont les configurations de journalisation recommandées pour les environnements de production?
    Dans les environnements de production, il est recommandé de personnaliser la configuration log4j2 pour éviter la duplication des journaux, activer la rotation des journaux et supprimer les annexes inutilisées.
  5. Comment puis-je forcer les applications à l’aide du système.OUT et SYSTÈME.err pour enregistrer?
    En ajoutant l’attribut SwallowOutput dans le contexte.Fichier XML, applications utilisant le système.OUT et SYSTÈME.ERR peut être obligé de se connecter.
  6. Les applications à l’aide du framework Jul peuvent être configurées pour utiliser log4j2?
    Oui, en modifiant la variable d’environnement Logging_Manager, les applications utilisant le framework Jul peuvent être configurées pour utiliser log4j2.
  7. Que dois-je faire pour utiliser Log4J2 avec Spring Boot?
    Pour utiliser LOG4J2 avec Spring Boot, excluez la dépendance de la boute de Spring-Boot-Starter et ajoutez Spring-Boot-Starter-Log4J2.
  8. Comment puis-je personnaliser les niveaux de journalisation pour des packages spécifiques dans Spring Boot?
    Les niveaux de journalisation pour des packages spécifiques peuvent être personnalisés en modifiant les propriétés de configuration de la journalisation dans le fichier de configuration de l’application.
  9. Est-il possible de désactiver la bannière de printemps à Spring Boot?
    Oui, la bannière de printemps peut être désactivée en définissant le ressort.principal.Propriété en mode bannière à désactiver dans le fichier de configuration de l’application.
  10. Pourquoi devrais-je utiliser LOG4J2 au lieu de l’implémentation de journalisation par défaut dans Tomcat?
    LOG4J2 offre une gamme plus large d’options de journalisation et d’annexe, ce qui le rend plus flexible et puissant par rapport à l’implémentation de journalisation par défaut dans Tomcat.

Réponses détaillées:

  1. Pourquoi devrais-je envisager d’utiliser Apache Tomcat 9 avec log4j2 pour la journalisation?
    Apache Tomcat 9 avec log4j2 fournit un système de journalisation plus avancé et plus flexible par rapport à l’implémentation de journalisation par défaut. Log4J2 offre une large gamme d’annexeurs et d’options de journalisation, vous permettant de personnaliser et de gérer efficacement vos journaux. La simplicité de la configuration de Log4J2 et sa capacité à rouler les fichiers journaux avec le nom d’origine en font un choix attrayant pour les configurations d’ingestion de journal. De plus, l’utilisation de log4j2 élimine les limites de l’API de journalisation des servlets, comme l’incapacité de contrôler les niveaux de journal.
  2. Comment configurer log4j2 avec Apache Tomcat?
    La configuration du log4j2 avec Apache Tomcat est simple. Tout d’abord, vous devez ajouter les bibliothèques LOG4J2-API, LOG4J2-Core et Log4j2-Appserver au Tomcat ClassPath. Ensuite, fournissez le fichier de configuration log4j2 dans votre projet. Enfin, supprimez la journalisation par défaut.Fichier de propriétés de votre installation Tomcat. La suite de ces étapes permettra Log4J2 comme cadre de journalisation de Tomcat.
  3. Pourquoi les bibliothèques Juli-Adapter ne sont-elles plus nécessaires dans Tomcat 8.5.4 et plus?
    Versions Tomcat 8.5.4 et ci-dessus introduit l’intégration directe avec Log4j2, éliminant le besoin de bibliothèques julili-adaptateurs. Log4j2 peut désormais être branché directement sur Java.user.journalisation, ce qui en fait un remplacement transparent pour l’API de journalisation des servlets. Cette intégration simplifie le processus de configuration de la journalisation et fournit plus de contrôle sur les niveaux de journal et les annexeurs.
  4. Quelles sont les configurations de journalisation recommandées pour les environnements de production?
    Lors de la configuration du log4j2 pour les environnements de production, plusieurs considérations doivent être prises en compte. Premièrement, il est important d’éviter de dupliquer les sorties de journal dans le Catalina.Fichier et Catalina.fichier journal. Cela peut être réalisé en supprimant le ConsoleHandler. Deuxièmement, il est recommandé de permettre la rotation des journaux pour la catalina.Fichier journal pour l’empêcher de croître trop grand. Enfin, en supprimant les annexes non utilisés comme le gestionnaire.journal et host_manager.Le journal peut aider à désencombrer la sortie du journal. De plus, l’adhésion à différents bûcherons en un seul appender, comme les journalistes de Catalina et LocalHost, peut simplifier le dépannage et identifier les problèmes de déploiement.
  5. Comment puis-je forcer les applications à l’aide du système.OUT et SYSTÈME.err pour enregistrer?
    Pour forcer les applications qui utilisent le système.OUT et SYSTÈME.err pour journaliser, vous pouvez ajouter l’attribut SwallowOutput au contexte par défaut.Fichier XML situé dans $ Catalina_Base / Conf / Context.xml. Cet attribut demande à Tomcat de rediriger le système.OUT et SYSTÈME.err au système de journalisation, en s’assurant que toutes les sorties sont capturées dans les journaux.
  6. Les applications à l’aide du framework Jul peuvent être configurées pour utiliser log4j2?
    Oui, les applications qui utilisent le framework Java (Java Util Logging) peuvent être configurées pour utiliser le log4j2. En modifiant la variable d’environnement Logging_Manager dans le setenv.fichier sh, vous pouvez définir la valeur sur “-djava.user.enregistrement.manager = org.apache.enregistrement.log4j.juil.Logmanager “. Cette configuration garantit que les applications utilisant Jul utiliseront le format log4j2 pour leurs journaux au lieu du format par défaut.
  7. Que dois-je faire pour utiliser Log4J2 avec Spring Boot?
    Pour utiliser LOG4J2 avec Spring Boot, vous devez exclure la dépendance par défaut de logage de Spring-Boot-Starter des différents artefacts de démarrage. Cela peut être fait en spécifiant <exclure>Spring-Boot-Starter-Logging</exclure> Dans la section des dépendances du POM de votre projet.fichier xml. Après avoir exclu la dépendance de la journalisation par défaut, vous pouvez ajouter la dépendance de Spring-Boot-Starter-Log4J2, qui comprend toutes les dépendances Log4J2 nécessaires et les dépendances SLF4J. Si vous n’utilisez aucune des fonctionnalités SLF4J, vous pouvez utiliser la dépendance log4j-web à la place.
  8. Comment puis-je personnaliser les niveaux de journalisation pour des packages spécifiques dans Spring Boot?
    Dans Spring Boot, vous pouvez personnaliser les niveaux de journalisation pour des packages spécifiques en modifiant la configuration de la journalisation dans les propriétés de l’application ou le fichier YAML. La syntaxe pour la personnalisation des niveaux de journalisation est enregistrement.niveau.package_name = niveau. Par exemple, si vous souhaitez définir le niveau de débogage pour l’organisation.Package SpringFramework “et le package” Hello “, vous pouvez ajouter la configuration suivante: enregistrement.niveau.org.SpringFramework = Debug et enregistrement.niveau.Bonjour = débogage.
  9. Est-il possible de désactiver la bannière de printemps à Spring Boot?
    Oui, il est possible de désactiver la bannière de printemps dans Spring Boot. En définissant le printemps.principal.mode Propriété pour “off” dans les propriétés de l’application ou le fichier YAML, vous pouvez empêcher la bannière d’apparaître dans la sortie de la console ou les fichiers journaux.
  10. Pourquoi devrais-je utiliser LOG4J2 au lieu de l’implémentation de journalisation par défaut dans Tomcat?
    LOG4J2 offre plusieurs avantages par rapport à l’implémentation de journalisation par défaut dans Tomcat. Il fournit une gamme plus large d’annexeurs et d’options de journalisation, vous permettant de personnaliser vos journaux en fonction de vos besoins. Log4j2 offre également plus de flexibilité dans le roulement du fichier journal, simplifiant les configurations d’ingestion de journal. De plus, Log4J2 élimine les limites de l’API de journalisation des servlets, comme l’incapacité de contrôler les niveaux de journal. Dans l’ensemble, l’utilisation de log4j2 peut améliorer votre expérience de journalisation à Tomcat.

Apache Tomcat 8

L’API de journalisation des servlets est antérieure au java.user.API de journalisation qui est maintenant fournie par Java. En tant que tel, il ne vous offre pas beaucoup d’options. E.g., Vous ne pouvez pas contrôler les niveaux de journal. On peut noter, cependant, que dans Apache Tomcat implémentation, les appels à servletContex.journal (chaîne) ou génériqueter.Le journal (chaîne) est enregistré au niveau des informations. Les appels à servletContext.journal (chaîne, jetable) ou génériqueter.Le journal (chaîne, jetable) est enregistré au niveau sévère.

Garder vos journaux propres avec Apache Tomcat 9, Log4j2 et Spring-Boot

Ces derniers jours, j’ai joué avec Apache Tomcat 9 et Log4j2. Vous vous demandez peut-être pourquoi je veux changer le bien un vieux Tomcat Juli. Eh bien, bien que j’aime la simplicité de sa configuration et le fait que Juli fonctionne, Log4J2 offre une grande variété d’annexe qui le rend très intéressant. Je préfère également la façon dont Log4j2 roule les fichiers, en gardant le nom d’origine non touché (E.g. Catalina.journal), cela rend ma configuration d’ingestion de journal (Logstash) un peu plus simple.

Apache Tomcat avec configuration log4j2

La configuration Apache-Tomcat est assez simple. Vous avez juste besoin d’ajouter les bibliothèques log4j2-api, log4j2-core et log4j2-appserver dans le Tomcat ClassPath, fournissent le fichier de configuration log4j2 et retirer le $ Catalina_base / conf / journalisation.propriétés de votre installation. Ces étapes sont décrites ici.

Si vous utilisez des versions Tomcat avant 8.5.4 Vous vous demandez peut-être ce qui s’est passé avec les bibliothèques Juli-Adapter des célèbres Tomcat Extras? Ils ne sont plus nécessaires, car Log4j2 peut être branché directement sur Java.user.journalisation, hourra! Voir plus chez ASF Bugzilla – Bug 58588

Configuration de la journalisation pour les environnements de production

Si vous exécutez une version Tomcat récente, vous pouvez voir que le chapitre “Utilisation de Log4j” des versions précédentes n’est pas toujours là. Vous pouvez avoir la tentation de réutiliser l’ancien log4j.propriétés qui reflètent le java par défaut.user.enregistrement. Soyez prudent, car la syntaxe des propriétés log4j2 a changé. Avec celui-ci (btw, merci Bryan Maupin. ) Vous obtiendrez la configuration par défaut avec les trois journalistes et annexeurs Tomcat par défaut. Pour une utilisation de la production, vous pouvez prendre en compte les considérations Tomcat Docs et les recommandations sur l’exploitation de l’exploitation Mark Thomas, Membre du comité de gestion de projet Apache Tomcat:

  1. Faire Nont dupliquer le tomcat sortir dans la catalina.Out (console) et dans le Catalina.Locage, se débarrasser du ConsoleHandler
  2. Ajouter rotation à votre Catalina.enregistrer
  3. Supprimer les annexes non utilisés directeur.journal et host_manager.enregistrer
  4. Rejoindre différent bûcherons (Catalina & localhost) un appender (Catalina.enregistrer). Ceci est utile pour repérer les problèmes de déploiement dans les applications comme les filtres à tort à tort.

La configuration log4j2 fournie dans l’exemple essaie de suivre ces considérations. Si vous commencez le serveur Tomcat avec et que votre Tomcat s’exécute “en bonne santé”, vous ne devriez voir presque rien dans la console. Avec cette configuration, dans la console, vous ne verrez que des choses très catastrophiques comme des eERRES OUTOFMORY.

Système de forçage.OUT et SYSTÈME.err pour enregistrer

Si nous déploient des applications sur notre serveur qui utilisent toujours Système.dehors et / ou Système.se tromper, Nous pouvons les forcer à utiliser notre enregistreur en ajoutant swallowOutput = “true” par défaut $ Catalina_Base / Conf / Context.xml du serveur. Nous pouvons également le faire par application, modifiant chacun de leurs méta-infr / contextes.xml.

Java Util Logging et Log4j2

Nous pouvons également avoir des applications qui utilisent le bon et l’ancien framework Jul:

01 avril 2019 9:22:05 AM Bonjour.HelloworldController Sayhello Info: Bonjour, juil.

Ces applications utiliseront la valeur par défaut enregistrement.propriétés de notre JDK, quel niveau par défaut est INFO et formater le simple format. Nous pouvons les forcer à utiliser notre format log4j2 modifiant la variable d’environnement Logging_manager. Vous pouvez le faire en ajoutant le setenv.shot Fichier: logging_manager = “- djava.user.enregistrement.manager = org.apache.enregistrement.log4j.juil.Logmanager “ Maintenant, vos journaux ressembleront à quelque chose comme ceci:

Tomcat 2019-04-01 09: 13: 53 524 [Catalina-Utility-1] Info Bonjour.HelloworldApplication - Bonjour, juil.

Rappelez-vous que org.apache.enregistrement.log4j.juil.Bmanager est inclus dans le log4j-jul-2.11.2.Bridge Jar qui doit être ajouté à votre chemin de classe.

Spring Boot et Log4j2

Nous voulons déployer une application Spring-Boot Hello, REST qui utilise notre configuration log4j2 (appender et format) et en même temps, nous voulons garder la capacité de définir différents journalistes. Par exemple, imaginons que nous voulons définir le niveau de débogage sur nos cours d’entreprise, le package Hello et les springframework. Et permet également de taire la bannière de printemps classique:

enregistrement.niveau.org.SpringFramework = Debug Logging.niveau.Bonjour = débogage du printemps.principal.mode bannière = off

Par défaut, les démarreurs Spring-Boot utilisent la journal exclure Spring-Boot-Starter-Logging des différents artefacts de démarrage et ajouter le Spring-Boot-Starter-Log4J2 dépendance. Ce dernier inclura toutes les dépendances log4j2 plus celles SLF4J. Il peut arriver que nous n’utilisions aucune des fonctionnalités SL4J, comme les messages paramétrisés, ou comme dans notre cas, nous voulons utiliser directement Log4j2. Si tel est votre cas, vous pouvez simplement ajouter le log4j-web dépendance. Soit dit en passant, c’est celui que vous devez ajouter pour les applications Web non printemps, voir davantage sur “Utilisation de Log4j dans les applications Web”.

Conclusion

Dans cette entrée, nous avons appris à configurer Apache Tomcat pour travailler avec log4j2, comment préparer cette configuration pour la production et comment déployer une application Spring-Boot dans notre serveur Tomcat qui utilise notre configuration. Vous pouvez trouver tout cela dans ce référentiel GitHub.

Passez une belle journée de codage!

Apache Tomcat 8

Tomcat Home

La journalisation interne pour Apache Tomcat utilise Juli, une fourche renommée emballée d’Apache Commons Logging qui, par défaut, est codé pour utiliser le java.user.Framework de journalisation. Cela garantit que la journalisation interne de Tomcat et toute journalisation de l’application Web resteront indépendantes, même si une application Web utilise la journalisation des communes Apache.

Pour configurer Tomcat pour utiliser un cadre de journalisation alternatif pour sa journalisation interne, il faut remplacer l’implémentation julinée qui est codé pour utiliser Java.user.Connexion avec une implémentation Juli qui conserve le mécanisme complet de découverte d’exploitation. Une telle implémentation est fournie comme un composant extras. Des instructions sur la façon de configurer Tomcat pour utiliser le framework log4j pour sa journalisation interne peuvent être trouvées ci-dessous.

Une application Web exécutée sur Apache Tomcat peut:

  • Utilisez n’importe quel cadre de journalisation de son choix.
  • Utilisez une API de journalisation du système, Java.user.enregistrement .
  • Utilisez l’API de journalisation fournie par la spécification Java Servlets, Javax.servlet.ServletContext.enregistrer(. )

Les cadres de journalisation utilisés par différentes applications Web sont indépendants. Voir le chargement de classe pour plus de détails. L’exception à cette règle est Java.user.enregistrement . S’il est utilisé directement ou indirectement par votre bibliothèque forestière, les éléments de celui-ci seront partagés sur les applications Web car il est chargé par le chargeur de classe système.

API Java Logging – Java.user.enregistrement

Apache Tomcat a sa propre implémentation de plusieurs éléments clés de Java.user.API de journalisation. Cette implémentation s’appelle Juli. Le composant clé Il y a une implémentation de connexion Custom, qui est consciente des différentes applications Web exécutées sur Tomcat (et leurs différents chargeurs de classe). Il prend en charge les configurations de journalisation privée par application. Il est également informé par Tomcat lorsqu’une application Web est déchargée de mémoire, afin que les références à ses classes puissent être effacées, empêchant les fuites de mémoire.

Ce java.user.L’implémentation de journalisation est activée en fournissant certaines propriétés système lors du démarrage de Java. Les scripts de démarrage d’Apache Tomcat le font pour vous, mais si vous utilisez différents outils pour exécuter Tomcat (comme JSVC, ou exécuter Tomcat à partir d’un IDE), vous devriez en prendre soin par vous-même par vous-même.

Plus de détails sur Java.user.La journalisation peut être trouvée dans la documentation de votre JDK et sur ses pages javadoc pour le java.user.package de journalisation.

Plus de détails sur Tomcat Juli peuvent être trouvés ci-dessous.

API de journalisation des servlets

Les appels à Javax.servlet.ServletContext.enregistrer(. ) Pour écrire des messages de journal sont gérés par journalisation interne Tomcat. Ces messages sont enregistrés dans la catégorie nommée

org.apache.Catalina.cœur.Base de conteneurs.[$].[$].[$]

Cette journalisation est effectuée en fonction de la configuration de journalisation Tomcat. Vous ne pouvez pas l’écraser dans une application Web.

L’API de journalisation des servlets est antérieure au java.user.API de journalisation qui est maintenant fournie par Java. En tant que tel, il ne vous offre pas beaucoup d’options. E.g., Vous ne pouvez pas contrôler les niveaux de journal. On peut noter, cependant, que dans Apache Tomcat implémentation, les appels à servletContex.journal (chaîne) ou génériqueter.Le journal (chaîne) est enregistré au niveau des informations. Les appels à servletContext.journal (chaîne, jetable) ou génériqueter.Le journal (chaîne, jetable) est enregistré au niveau sévère.

Console

Lors de l’exécution de Tomcat sur Unixes, la sortie de la console est généralement redirigée vers le fichier nommé Catalina.dehors . Le nom est configurable à l’aide d’une variable d’environnement. (Voir les scripts de démarrage). Tout ce qui est écrit sur le système.err / out sera pris dans ce fichier. Qui peut inclure:

  • Exceptions non revues imprimées par Java.égouter.Group thread.exception non interceptée(..)
  • Décharges de threads, si vous les avez demandés via un signal système

Lors de l’exécution en tant que service sous Windows, la sortie de la console est également capturée et redirigeante, mais les noms de fichiers sont différents.

La configuration de journalisation par défaut dans Apache Tomcat écrit les mêmes messages à la console et à un fichier journal. C’est génial lors de l’utilisation de Tomcat pour le développement, mais n’est généralement pas nécessaire en production.

Anciennes applications qui utilisent encore le système.out ou système.ERR peut être trompé en définissant l’attribut SwallowOutput sur un contexte. Si l’attribut est défini sur true, les appels vers le système.OUT / ERR pendant le traitement de la demande sera intercepté, et leur sortie sera transmise au sous-système de journalisation à l’aide du Javax.servlet.ServletContext.enregistrer(. ) appels.
Note, que la fonction SwallowOutput est en fait une astuce, et elle a ses limites. Il ne fonctionne qu’avec des appels directs vers le système.out / err, et seulement pendant le cycle de traitement de la demande. Il peut ne pas fonctionner dans d’autres threads qui pourraient être créés par l’application. Il ne peut pas être utilisé pour intercepter les cadres de journalisation qui eux-mêmes écrivent dans les flux système, car ceux-ci commencent tôt et peuvent obtenir une référence directe aux flux avant que la redirection n’ait lieu.

Journalisation d’accès

L’enregistrement d’accès est une fonctionnalité liée mais différente, qui est implémentée comme une valve . Il utilise une logique autonome pour écrire ses fichiers journaux. L’exigence essentielle de journalisation d’accès est de gérer un grand flux continu de données avec des frais généraux faibles, il n’utilise donc qu’Apache Commons Logging pour ses propres messages de débogage. Cette approche de mise en œuvre évite les frais généraux supplémentaires et la configuration potentiellement complexe. Veuillez vous référer à la documentation des vannes pour plus de détails sur sa configuration, y compris les différents formats de rapport.

Utilisation de Java.user.journalisation (par défaut)

L’implémentation par défaut de Java.user.La journalisation fournie dans le JDK est trop limitée pour être utile. La limitation clé est l’incapacité d’avoir une journalisation de l’application par Web, car la configuration est par VM. En conséquence, Tomcat remplacera, dans la configuration par défaut, l’implémentation de Logmanager par défaut par une implémentation conviviale appelée Juli, qui traite de ces lacunes.

Juli prend en charge les mêmes mécanismes de configuration que le JDK Java standard.user.Enregistrement, en utilisant soit une approche programmatique ou des fichiers de propriétés. La principale différence est que les fichiers de propriétés par classement peuvent être définis (ce qui permet une configuration WebApp facultative facile à redéploiement), et les fichiers de propriétés prennent en charge les constructions étendues qui permet plus de liberté pour définir les gestionnaires et les attribuer aux journalistes.

Juli est activé par défaut et prend en charge par configuration de Classloader, en plus du Java global régulier.user.configuration de journalisation. Cela signifie que la journalisation peut être configurée aux couches suivantes:

  • Globalement. Cela se fait généralement dans le $ / conf / journalisation.Fichier de propriétés. Le fichier est spécifié par le java.user.enregistrement.configurer.Propriété du système de fichiers définie par les scripts de démarrage. S’il n’est pas lisible ou n’est pas configuré, la valeur par défaut est d’utiliser le $ / lib / journalisation.Fichier de propriétés dans le JRE.
  • Dans l’application Web. Le fichier sera Web-inf / classes / journalisation.propriétés

La journalisation par défaut.Les propriétés du JRE spécifie un ConsoleHandler qui achemine la journalisation vers le système.se tromper. La confe / journalisation par défaut.Les propriétés dans Apache Tomcat ajoutent également plusieurs fichiers qui écrivent dans les fichiers.

Le seuil de niveau de journal d’un gestionnaire est par défaut d’informations et peut être défini en utilisant sévère, avertissement, informations, config, fin, plus fin, plus fini ou tous. Vous pouvez également cibler des packages spécifiques pour collecter la journalisation et spécifier un niveau.

Pour permettre la journalisation de débogage pour une partie des internes de Tomcat, vous devez configurer à la fois le (s) enregistrement (s) approprié et le ou les gestionnaires appropriés pour utiliser le meilleur ou tous les niveaux. e.g.:

org.apache.Catalina.session.niveau = tout java.user.enregistrement.Consoleur.niveau = tout

Lors de l’activation de l’exploitation de débogage, il est recommandé qu’il soit activé pour la portée la plus étroite possible car la journalisation de débogage peut générer de grandes quantités d’informations.

La configuration utilisée par Juli est la même que celle prise en charge par Plain Java.user.journalisation, mais utilise quelques extensions pour permettre une meilleure flexibilité dans la configuration des enregistreurs et des gestionnaires. Les principales différences sont:

  • Un préfixe peut être ajouté aux noms de gestionnaire, afin que plusieurs gestionnaires d’une seule classe puissent être instanciés. Un préfixe est une chaîne qui commence par un chiffre, et se termine par ‘.’. Par exemple, 22foobar. est un préfixe valide.
  • Le remplacement de la propriété système est effectué pour les valeurs des propriétés qui contiennent $.
  • Si vous utilisez un chargeur de classe qui implémente l’organisation.apache.juri.Interface WebApproperties (le chargeur de classe d’application Web de Tomcat le fait) alors le remplacement de la propriété est également effectué pour $, $ et $ qui sont remplacés par le nom de l’application Web, le nom d’hôte et le nom du service respectivement.
  • Par défaut, les journalistes ne délégueront pas à leur parent s’ils ont des gestionnaires associés. Cela peut être modifié par logger en utilisant le nom de logger.Propriété UseParentHandlers, qui accepte une valeur booléenne.
  • Le journal de racine peut définir son ensemble de gestionnaires en utilisant le .propriété des gestionnaires.
  • Par défaut, les fichiers journaux seront conservés sur le système de fichiers pour toujours. Cela peut être modifié par gestionnaire en utilisant le handlername.Propriété Maxdays. Si la valeur spécifiée pour la propriété est

Il existe plusieurs classes d’implémentation supplémentaires, qui peuvent être utilisées avec celles fournies par Java. Le notable est l’org.apache.juri.File .

org.apache.juri.FileHandler prend en charge la mise en mémoire tampon des journaux. La mise en mémoire tampon n’est pas activée par défaut. Pour le configurer, utilisez la propriété BufferSize d’un gestionnaire. La valeur de 0 utilise la mise en mémoire tampon par défaut du système (généralement un tampon 8K sera utilisé). Une valeur de 0 utilise un tampon de tampon avec la valeur définie mais notez que la mise en mémoire tampon par défaut du système sera également appliquée.

Exemple de journalisation.Fichier de propriétés à placer dans $ Catalina_Base / conf:

Handlers = 1catalina.org.apache.juri.FileHandler, \ 2LocalHost.org.apache.juri.Filehandler, \ 3Manager.org.apache.juri.Filehandler, \ java.user.enregistrement.Consoleur .Handlers = 1catalina.org.apache.juri.FileHandler, Java.user.enregistrement.Consolehandler ############################################################## # Propriétés spécifiques du gestionnaire. # Décrit des informations de configuration spécifiques pour les gestionnaires. ############################################################ ###################.org.apache.juri.File.Niveau = Fine 1Catalina.org.apache.juri.File.répertoire = $ / logs 1catalina.org.apache.juri.File.Prefix = Catalina. 2Localhost.org.apache.juri.File.niveau = fin 2Localhost.org.apache.juri.File.répertoire = $ / logs 2LocalHost.org.apache.juri.File.préfixe = localhost. 3manager.org.apache.juri.File.Niveau = Fine 3manager.org.apache.juri.File.répertoire = $ / logs 3Manager.org.apache.juri.File.préfixe = manager. 3manager.org.apache.juri.File.BufferSize = 16384 Java.user.enregistrement.Consoleur.Niveau = Fine Java.user.enregistrement.Consoleur.format = java.user.enregistrement.SimpleFormatter ############################################################### # Propriétés spécifiques de l'installation. # Fournit un contrôle supplémentaire pour chaque enregistreur. ############################################################.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].Niveau = Info org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].Handlers = \ 2LocalHost.org.apache.juri.Org de fichier.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].[/directeur].Niveau = Info org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].[/directeur].Handlers = \ 3Manager.org.apache.juri.FileHandler # Par exemple, définissez l'organisation.apache.Catalina.user.Lifecyclebase Logger pour enregistrer # chaque composant qui étend l'état de modification de la base de vie: #org.apache.Catalina.user.Base de cycle de vie.Niveau = Fine

Exemple de journalisation.Propriétés de l’application Web Servlet-Examples à placer dans des classes Web / classes dans l’application Web:

Handlers = org.apache.juri.FileHandler, Java.user.enregistrement.Consolehandler ############################################################## # Propriétés spécifiques du gestionnaire. # Décrit des informations de configuration spécifiques pour les gestionnaires. ############################################################.apache.juri.File.Niveau = Org Fine.apache.juri.File.répertoire = $ / logs org.apache.juri.File.préfixe = $. Java.user.enregistrement.Consoleur.Niveau = Fine Java.user.enregistrement.Consoleur.format = java.user.enregistrement.Simple format

Références de documentation

Voir les ressources suivantes pour plus d’informations:

  • Apache Tomcat Javadoc pour l’organisation.apache.package juliné.
  • Oracle Java 6 Javadoc pour le java.user.package de journalisation.

Considérations pour l’utilisation de la production

Vous voudrez peut-être prendre note des éléments suivants:

  • Envisagez de supprimer la configuration de ConsoleHandler de. Par défaut (grâce au .Paramètres des gestionnaires) La journalisation va à la fois à un fichier Handleur et à un ConsoleHandler . La sortie de ce dernier est généralement capturée dans un fichier, comme Catalina.dehors . Ainsi, vous vous retrouvez avec deux copies des mêmes messages.
  • Envisagez de supprimer FileHandler pour les applications que vous n’utilisez pas. E.g., Celui pour l’hôte-manager .
  • Les gestionnaires par défaut utilisent le codage par défaut du système pour écrire les fichiers journaux. Il peut être configuré avec une propriété d’encodage. Voir Javadoc pour plus de détails.
  • Envisagez de configurer un journal d’accès.

Utilisation de log4j

Cette section explique comment configurer Tomcat pour utiliser Log4j plutôt que Java.user.journalisation pour la journalisation interne de Tomcat.

Note: Les étapes décrites dans cette section sont nécessaires lorsque vous souhaitez reconfigurer Tomcat pour utiliser Apache Log4J pour sa propre journalisation. Ces étapes sont pas nécessaire si vous souhaitez simplement utiliser LOG4J dans votre propre application Web. – Dans ce cas, il suffit de mettre Log4J.pot et log4j.Propriétés dans le Web-Inf / Lib et le Web-Inf / Classes de votre application Web.

Les étapes suivantes décrivent la configuration de log4j pour sortir la journalisation interne de Tomcat.

  1. Créer un fichier appelé log4j.Propriétés avec le contenu suivant et économisez-le dans $ Catalina_base / lib

 log4j.rootLogger = info, cataina # définir tous les annexeurs log4j.appender.Catalina = org.apache.log4j.DailyrollingFileAPpender log4j.appender.Catalina.File = $ / logs / cataina log4j.appender.Catalina.APPENDE = VRAI LOG4J.appender.Catalina.Encoding = UTF-8 # Roll-Over le journal une fois par jour log4j.appender.Catalina.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.Catalina.disposition = org.apache.log4j.Patternlayout log4j.appender.Catalina.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Localhost = org.apache.log4j.DailyrollingFileAPpender log4j.appender.Hôte local.File = $ / logs / localhost log4j.appender.Hôte local.APPENDE = VRAI LOG4J.appender.Hôte local.Encodage = UTF-8 LOG4J.appender.Hôte local.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.Hôte local.disposition = org.apache.log4j.Patternlayout log4j.appender.Hôte local.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Manager = org.apache.log4j.DailyrollingFileAPpender log4j.appender.DIRECTEUR.File = $ / logs / manager log4j.appender.DIRECTEUR.APPENDE = VRAI LOG4J.appender.DIRECTEUR.Encodage = UTF-8 LOG4J.appender.DIRECTEUR.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.DIRECTEUR.disposition = org.apache.log4j.Patternlayout log4j.appender.DIRECTEUR.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Host-manager = org.apache.log4j.DailyrollingFileAPpender log4j.appender.Manager hôte.File = $ / logs / host-manager log4j.appender.Manager hôte.APPENDE = VRAI LOG4J.appender.Manager hôte.Encodage = UTF-8 LOG4J.appender.Manager hôte.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.Manager hôte.disposition = org.apache.log4j.Patternlayout log4j.appender.Manager hôte.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Console = org.apache.log4j.ConsoleAppender log4j.appender.CONSOLE.Encodage = UTF-8 LOG4J.appender.CONSOLE.disposition = org.apache.log4j.Patternlayout log4j.appender.CONSOLE.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n # Configurez les journalistes qui se connectent aux annexes log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost] = info, localhost log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].[/ manager] = \ info, manager log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].[/ host-manager] = \ info, host-manager

  1. Télécharger Log4j (Tomcat nécessite V1.2.X).
  2. Télécharger ou construire Tomcat-Juli.Jar et Tomcat-Juli-adaptrices.pot disponible en tant que composant “extras” pour Tomcat. Voir la documentation supplémentaire des composants pour plus de détails. Ce tomcat-juli.Le pot diffère de celui par défaut. Il contient l’implémentation complète de la journalisation Apache Commons et est donc capable de découvrir la présence de log4j et de se configurer.
  3. Si vous souhaitez configurer Tomcat pour utiliser Log4j globalement:
    • Mettre Log4j.Jar et Tomcat-Juli-adaptrices.pot de “extras” dans $ catalina_home / lib .
    • Remplacez $ Catalina_Home / Bin / Tomcat-Juli.pot avec tomcat-juli.pot de “extras”.
  4. Si vous exécutez Tomcat avec des $ Catalina_home séparés et $ cataina_base et que vous souhaitez configurer pour utiliser Log4j dans un seul $ cataina_base uniquement:
    • Créer $ Catalina_Base / Bin et $ Catalina_base / lib répertoires s’ils n’existent pas.
    • Mettre Log4j.Jar et Tomcat-Juli-adaptrices.pot de “extras” dans $ catalina_base / lib
    • Mettre Tomcat-Juli.pot de “extras” comme $ cataina_base / bin / tomcat-juli.pot
    • Si vous courez avec un responsable de la sécurité, vous devrez modifier le $ Catalina_Base / conf / Catalina.Fichier de stratégie pour l’ajuster à une autre copie de Tomcat-Juli.pot.

Remarque: Cela fonctionne parce que les bibliothèques, si elles existent dans $ Catalina_Base, sont chargées de préférence à la même bibliothèque dans $ Catalina_Home .

Remarque: Tomcat-Juli.Le pot est chargé à partir de $ cataina_base / bin pas $ catalina_base / lib car il est chargé dans le cadre du processus d’amorçage et toutes les classes bootstrap sont chargées à partir de bacs.

Cette configuration log4j reflète le java par défaut.user.La configuration de la journalisation qui est livrée avec Tomcat: le gestionnaire et les applications de manager hôte obtiennent un fichier journal individuel, et tout le reste va au “Catalina.Journal “Fichier journal. Chaque fichier est roulé une fois par jour.

Vous pouvez (et devriez) être plus pointilleux sur les packages à inclure dans l’exploitation forestière. Tomcat définit les journalistes par moteur et noms d’hôtes. Par exemple, pour un journal Catalina LocalHost plus détaillé, ajoutez-le à la fin du log4j.Propriétés ci-dessus. Notez qu’il existe des problèmes connus avec l’utilisation de cette convention de dénomination (avec des crochets) dans des fichiers de configuration basés sur le XML LOG4J, nous vous recommandons donc d’utiliser un fichier de propriétés comme décrit jusqu’à ce qu’une future version de log4j autorise cette convention.

log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost] = debug log4j.bûcheron.org.apache.Catalina.noyau = débogage log4j.bûcheron.org.apache.Catalina.session = débogage

Soyez averti: un niveau de débogage produira des mégaoctets de journalisation et de démarrage lent de Tomcat. Ce niveau doit être utilisé avec parcimonie lors du débogage des opérations internes de Tomcat.

Vos applications Web devraient certainement utiliser leur propre configuration log4j. C’est valable avec la configuration ci-dessus. Vous placerait un log4j similaire.Fichier de propriétés dans le répertoire Web-inff / classes de votre application Web et log4jx.y.z.pot dans le web-inf / lib. Puis spécifiez la journalisation de votre niveau de package. Ceci est une configuration de base de log4j qui ne nécessite * pas * de chariot, et vous devriez consulter la documentation log4j pour plus d’options. Cette page est destinée uniquement à un guide d’amorçage.

  • Cela expose les bibliothèques log4j aux applications Web via le Classloader commun. Voir la documentation de chargement de classe pour plus de détails. Pour cette raison, les applications Web et les bibliothèques utilisant la bibliothèque de journalisation Apache Commons devraient choisir automatiquement Log4J comme l’implémentation de journalisation sous-jacente.
  • Le java.user.L’API de journalisation est toujours disponible pour les applications Web qui l’utilisent directement. Le $ / conf / journalisation.Le fichier de propriétés est toujours référencé par les scripts de démarrage de Tomcat. Pour plus d’informations, consultez les sous-sections de l’introduction à cette page. Suppression de $ / conf / journalisation.Le fichier de propriétés, mentionné comme l’une des étapes ci-dessus, provoque Java.user.Enregistrement vers le secours à la configuration par défaut du JRE, qui consiste à utiliser un ConsoleHandler et donc à ne pas créer de fichiers journaux standard. Vous devez confirmer que tous vos fichiers journaux sont créés par log4j avant désactiver le mécanisme standard.
  • Le Valve de journal d’accès et Prolongée accesslogvalve Utilisez leur propre implémentation de journalisation autonome, afin qu’ils ne peut pas être configuré pour utiliser log4j. Reportez-vous à des vannes pour des détails de configuration spécifiques.

commentaires

Avis: Cette section de commentaires recueille vos suggestions sur l’amélioration de la documentation pour Apache Tomcat.

Si vous avez des problèmes et avez besoin d’aide, lisez la page d’aide Trouver et posez votre question sur la liste de diffusion Tomcat-Users. Ne posez pas de telles questions ici. Ce n’est pas une section Q&R.

Le système de commentaires Apache est expliqué ici. Les commentaires peuvent être supprimés par nos modérateurs s’ils sont mis en œuvre ou considérés comme invalides / hors sujet.

Configuration Tomcat Log4j étape par étape

Serveur Apache Tomcat J2EE

La bibliothèque et la configuration de Juli Logging sont disponibles par défaut avec le programme d’installation de Tomcat. Afin d’utiliser LOG4J pour la journalisation interne Tomcat à la place, vous devrez remplacer la bibliothèque Juli existante par l’intégration log4j-julinée.

1. Supprimez la bibliothèque Juli existante (Catalina_Home / Bin / Tomcat-Juli.Fichier JAR) et le fichier de configuration de journalisation Tomcat Java existant (Catalina_Home / conf / Logging.propriétés).

2. Télécharger la bibliothèque Juli Log4J Tomcat (Tomcat-Juli.jar) des téléchargements de tomcat’ Section des extras (http: // tomcat.apache.org / download-70.cgi). Placer le fichier téléchargé dans le répertoire Catalina_Home / Bin.

3. Télécharger la bibliothèque des adaptateurs Tomcat Juli (Tomcat-Juli-adaptrices.jar) des téléchargements de tomcat’ Section des extras. Placer ce fichier dans le répertoire Catalina_Home / Lib.

4. Télécharger log4j (version 1.2 ou version ultérieure), et placez le fichier de bibliothèque téléchargé dans le répertoire Catalina_Home / Lib.

5. Créez le fichier de configuration log4j à l’emplacement suivant: Catalina_home / lib / log4j.propriétés. Vérifiez ci-dessous la configuration log4j correspondant à la configuration de journalisation Java par défaut.

6. Redémarrer Tomcat.

Fichier de configuration log4j correspondant aux paramètres de journalisation Tomcat par défaut:

log4j.rootLogger = info, cataina # définir tous les annexeurs log4j.appender.Catalina = org.apache.log4j.DailyrollingFileAPpender log4j.appender.Catalina.Fichier = $ / logs / cataina. log4j.appender.Catalina.APPENDE = VRAI LOG4J.appender.Catalina.Encoding = UTF-8 # Roll-Over le journal une fois par jour log4j.appender.Catalina.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.Catalina.disposition = org.apache.log4j.Patternlayout log4j.appender.Catalina.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Localhost = org.apache.log4j.DailyrollingFileAPpender log4j.appender.Hôte local.Fichier = $ / logs / localhost. log4j.appender.Hôte local.APPENDE = VRAI LOG4J.appender.Hôte local.Encodage = UTF-8 LOG4J.appender.Hôte local.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.Hôte local.disposition = org.apache.log4j.Patternlayout log4j.appender.Hôte local.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Manager = org.apache.log4j.DailyrollingFileAPpender log4j.appender.DIRECTEUR.Fichier = $ / logs / manager. log4j.appender.DIRECTEUR.APPENDE = VRAI LOG4J.appender.DIRECTEUR.Encodage = UTF-8 LOG4J.appender.DIRECTEUR.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.DIRECTEUR.disposition = org.apache.log4j.Patternlayout log4j.appender.DIRECTEUR.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Host-manager = org.apache.log4j.DailyrollingFileAPpender log4j.appender.Manager hôte.File = $ / logs / host-manager. log4j.appender.Manager hôte.APPENDE = VRAI LOG4J.appender.Manager hôte.Encodage = UTF-8 LOG4J.appender.Manager hôte.Datepattern = '.'yyyy-mm-dd'.Log 'log4j.appender.Manager hôte.disposition = org.apache.log4j.Patternlayout log4j.appender.Manager hôte.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n log4j.appender.Console = org.apache.log4j.ConsoleAppender log4j.appender.CONSOLE.Encodage = UTF-8 LOG4J.appender.CONSOLE.disposition = org.apache.log4j.Patternlayout log4j.appender.CONSOLE.mise en page.ConversionPattern =% d [% t]% -5p% c-% m% n # Configurez les journalistes qui se connectent aux annexes log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost] = info, localhost log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].[/ manager] = info, manager log4j.bûcheron.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].[/ host-manager] = info, hôte-manager

Tomcat utilisera désormais log4j pour toute journalisation interne.

Pour comprendre la configuration ci-dessus, vérifiez les détails ci-dessous pour obtenir une vue claire

Éléments de configuration pour log4j’S Patternlayout

% D Date de journalisation. Vous pouvez spécifier le modèle de date dans les supports bouclés (% D)% C Nom de classe entièrement qualifiée (Utilisez% C pour imprimer uniquement le nom de classe simple)% T Nom du thread où la journalisation s'est produite% F Nom de fichier de l'événement de journalisation% P Sépréateur de ligne Perme% L Numéro de l'événement de journalisation% M Le message de journalisation réel% n séparateur de ligne (ajoutez-le à la fin du modèle pour forcer la nouvelle ligne)

Voici quelques-uns des exemples de motifs et les entrées de journal qu’ils ont générées:

% d [% t]% -5p% c -% m% n 2011-09-07 14: 07: 41 509 [Main] Info myntclass - Exécution.

% 5p [% t] (% f:% l) -% m% n info [main] (myntclass.Java: 12) - Exécution.

Pour plus d’informations sur le lien LOG4J CHECHOT ci-dessous:

http: // journalisation.apache.org / log4j / index.html

Dans le cas de tout © Copyright ou Missing Credits Issue, veuillez consulter la page des droits d’auteur pour des résolutions plus rapides.

Comme l’article. Partagez-le.

  • Cliquez pour imprimer (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour envoyer un lien par e-mail à un ami (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur reddit (ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Pinterest (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur LinkedIn (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur WhatsApp (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Twitter (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Facebook (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Tumblr (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Pocket (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Telegram (s’ouvre dans une nouvelle fenêtre)
  • Cliquez pour partager sur Skype (s’ouvre dans une nouvelle fenêtre)

Comment: Configurer Tomcat 9 pour se connecter via Log4j2

Comment pouvez-vous rediriger la journalisation interne de Tomcat 9 (Catalina et LocalHost) vers Log4J2? Bien qu’il existe de nombreux guides disponibles pour les versions plus anciennes de Tomcat et Log4J, je n’ai rien trouvé “complet” concernant Tomcat 9 et Log4j2; La documentation d’Apache Tomcat 9 pointe vers “les instructions fournies par le cadre de journalisation alternative”, et les états de documentation APACH LOG4J (noms JAR dans 2. corrigée):

  1. Création d’un ensemble de répertoires dans Catalina Home nommé log4j2 / lib et log4j2 / conf.
  2. Placement de log4j-api-2.12.0.pot, log4j-core-2.12.0.pot et log4j-appserver-2.12.0.pot dans le répertoire log4j2 / lib.
  3. Création d’un fichier nommé log4j2-tomcat.xml, log4j2-tomcat.JSON, log4j2-tomcat.yaml, log4j2-tomcat.yml ou log4j2-tomcat.Propriétés dans le répertoire log4j2 / confre.
  4. Créer ou modifier setenv.sh dans le répertoire Tomcat Bin pour inclure ClassPath = $ Catalina_Home / Log4j2 / Lib / *: $ Catalina_Home / Log4j2 / confis

Mais que mettre dans ce log4j2-tomcat.* Fichier de configuration?

a demandé le 5 juillet 2019 à 12:33

682 1 1 badge d’or 6 6 badges en argent 17 17 badges en bronze

2 Réponses 2

J’ai trouvé un exemple de fichier de propriétés dans la documentation Apache Tomcat 7, mais comme celle-ci est destinée à être utilisée avec log4j 1.x, j’ai dû l’adapter à la syntaxe du fichier des propriétés log4j2. C’est le résultat:

# 'Status' fait référence aux messages de journal de Log4J2 lui-même monitorinterval = 30 status = Propriété Warn.logevel.Catalina = propriété info.logevel.LocalHost = propriété info.disposition.Catalina =% d% -5p [% t]% -22.Propriété 22c% m% n.disposition.localhost =% d% -5p [% t]% -30.30c% m% n # Roll-Over les journaux une fois par mois en utilisant CrontriggerPolicy. propriété.FiledatePattern.Propriété Catalina =% D.FiledatePattern.propriété localhost =% d.bronzer.Catalina = 0 0 0 1 * ? propriété.bronzer.localhost = 0 0 0 1 * ? ## Annexe # n.B.: - Pas besoin de spécifier «Annexes = Catalina, localhost, console» # puisque ces identifiants ne contiennent pas ».' personnages. # - Les «politiques» et «Cron» des identifiants sous-composants sont arbitrairement # choisis; Le type réel est spécifié via l'attribut 'type'. # - 'DirectWriterolloverstrategy' est utilisé automatiquement car aucun `` nom de fichier '' spécifié. appender.Catalina.Type = APPRENDRE ROLLING.Catalina.name = appender rollingfile-catalina.Catalina.filepattern = $ / logs / catalina.$.journal de journal.Catalina.mise en page.Type = Patternlayout Appeder.Catalina.mise en page.modèle = $ appender.Catalina.Stratégies.Type = Politiques Appeder.Catalina.Stratégies.cron.Type = APPENDRE CRRERGRIGHINGPOLICY.Catalina.Stratégies.cron.calendrier = $ appender.Catalina.Stratégies.cron.évaluerOnStartup = True appender.Catalina.filepermissions = RW-R ----- Appeder.Catalina.Fileowner = appender Tomcat.Catalina.fileGroup = ADMPPinder.Hôte local.Type = APPRENDRE ROLLING.Hôte local.name = RollingFile-LocalHost Appeder.Hôte local.filepattern = $ / logs / localhost.$.journal de journal.Hôte local.mise en page.Type = Patternlayout Appeder.Hôte local.mise en page.modèle = $ appender.Hôte local.Stratégies.Type = Politiques Appeder.Hôte local.Stratégies.cron.Type = APPENDRE CRRERGRIGHINGPOLICY.Hôte local.Stratégies.cron.calendrier = $ appender.Hôte local.Stratégies.cron.évaluerOnStartup = True appender.Hôte local.filepermissions = RW-R ----- Appeder.Hôte local.Fileowner = appender Tomcat.Hôte local.FileGroup = Adm # Uncomment si vous souhaitez continuer à enregistrer à Catalina.OUT APRÈS LOG4J2 PRENDRE. #apprender.CONSOLE.Type = console #APPENDER.CONSOLE.name = stdout #appender.CONSOLE.mise en page.Type = Patternlayout ## Configurez les journalistes du journal à quels annexes rootlogger.niveau = $ rootlogger.AppenderRef.Catalina.Ref = RollingFile-Catalina #Rootlogger.AppenderRef.stdout.ref = stdout # ici, l'identifiant contient '.'caractères, nous devons donc spécifier la liste. Locgers = org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[LocalHost] Logueur.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].name = logger localhost.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].niveau = $ logger.org.apache.Catalina.cœur.Base de conteneurs.[Catalina].[localhost].AppenderRef.Hôte local.ref = RollingFile-Localhost

La raison principale pour moi d’utiliser Log4J2 était de pouvoir obtenir une rotation de journal mensuelle, mais vous pouvez facilement ajuster tout comme vous le souhaitez, même sans redémarrer Tomcat.