Associer un code d'erreur spécifique au contexte dans Log4J

Associer un code d'erreur spécifique au contexte dans Log4J - Java - Programmation

Marsh Posté le 12-02-2004 à 10:32:49    

Salut,
 
Je viens de me faire "avoir" encore chez un de mes clients chez qui je viens de passer une appli Java en production. Comme la machine va être infogérée, l'infogéreur va utiliser un système de "monitoring" genre Tivoli pour automatiser la surveillance des applis.
 
Problème: mon appli qui génère une log au format Log4J n'est pas "pluggable" telle quelle "sur" Tivoli. Il faut que pour chaque exception, message d'erreur qui est susceptible d'arriver, j'associe un code sur 4 positions numériques (par exemple) identifiant le contexte de l'erreur. A partir de ce code, Tivoli est capable de déclencher des alertes s'il a été correctement paramétre. Ensuite, pour chaque code d'erreur, on doit spécifier l'action que l'infogérance doit entreprendre...
 
Question: Comment puis-je faire sans avoir a me repalucher toutes les throw & catch d'exceptions pour insérer un code d'erreur spécifique au contexte de mon exception ?
 
PS: Dans le pire des cas, je mets en début du message que je logge mon code d'erreur comme "VWXY - Erreur JMS", ce qui crée une pseudo-colonne dans ma log... Mais je trouve pas ça terrible quand même :/
 
Merci de vos réponses

Reply

Marsh Posté le 12-02-2004 à 10:32:49   

Reply

Marsh Posté le 12-02-2004 à 10:35:00    

Ta question n'est pas claire. Quels sont les contextes en question?


Message édité par darklord le 12-02-2004 à 10:35:10
Reply

Marsh Posté le 12-02-2004 à 10:38:36    

Eh bien, par exemple, si je suis susceptible de lever une exception comme une XMLException. Dans un cas ma XMLException sera associée à un code d'erreur 100 car elle intervient dans le chargement du paramétrage. Puis dans un cas de traitement d'un fichier XML quelconque, ce devra être un autre code d'erreur, disons 200, car le contexte sera différent.
 
Bref, le code d'erreur n'est pas spécifique à l'exception mais au contexte dans lequel celle-ci a été rencontrée.

Reply

Marsh Posté le 12-02-2004 à 10:39:59    

Ca me fait vraiment marrer ca. Et donc log4j il est censé trouver tout seul les contextes en question. C'est meme pas basé sur l'exception?
Tu comptais faire comment excepté te palucher toutes tes lignes de log comme tu dis?

Reply

Marsh Posté le 12-02-2004 à 11:13:05    

Est-ce-que t'es obligé de tout le temps prendre les gens de haut comme ça ? On sait que t'es une bête en java, c'est bon...
 
Je me doute bien que je vais être obligé, si je veux mettre quelquechose de propre en place, de retoucher à toute la gestion des exceptions. J'aurai pas dû mettre ça dans mon 1er post (que je voulais pas me "repalucher toute la gestion des exceptions" ).  
 
Maintenant, comment est-ce-que je peux mettre en place de système de code d'erreur basé sur le contexte de la levée de l'exception ?
 
J'avais pensé à déclarer un attribut errorCode de type int dans une exception générique dont hériterait toutes mes exceptions. Puis à étendre les classes de Log4J pour gérer ce nouvel attribut...

Reply

Marsh Posté le 12-02-2004 à 11:16:55    

non mais attends ca n'a rien à voir avec le fait d'etre bon en X ou Y. Je sais que je suis intélorant, je ne le nie pas mais bon ton post m'a donné l'impression que t'as pas réfléchi plus de 3 secondes et ca ca m'énerve [:spamafote]
 
Bon alors y a plusieurs solutions.
 
# Tu crées ton propre logger qui hérite du logger de log4j et tu redéfinis les méthodes de log pour qu'elle accepte un code d'erreur
# Y a un truc en log4j qui permet d'attacher un contexte à une exception (MDC si mes souvenirs sont bon). Rien ne t'empeche d'attacher le code d'erreur en question et redéfinir PatternLayout pour qu'il accpète un nouveau tag qui serait un attribute de conctexte (ton code d'erreur quoi).
 
Si tu veux une autre solution que logger.error("[XYZA] Failed to ...", e); il va falloir redéfinir le comportement par défaut (toujours à ce que je sais)

Reply

Marsh Posté le 12-02-2004 à 11:26:34    

Merci pour ta réponse.
 
En fait, si j'ai réfléchi + de 3 secondes à ce problème car j'y ai été déjà confronté par le passé chez 2 clients différents. A l'époque, j'avais créé une sorte de ApplicationException avec un attribut de type errorCode (int). A chaque fois que je levais une ApplicationException ou l'une de ses sous-classes, je passais au constructeur ce fameux code d'erreur dépendant du contexte.
 
J'avais aussi modifié le PatternLayout afin de gérer un nouveau "joker" (%e si je me rappelle bien) qui tentait sur l'exception à logger d'extraire le code d'erreur... Et aussi crée un nouveau PatternParser...
 
Ca marchait bien mais uniquement dans le cas où l'on loggait des exceptions.
 
Désormais je veux mettre en place le code d'erreur aussi quand je logge de simples messages...
 
je pense que je vais devoir m'en tenir à ce que j'ai déjà fait + faire ce que tu me conseilles, c-a-d, créer mon propre logger avec des méthodes error(int, String)...

Reply

Marsh Posté le 12-02-2004 à 11:35:23    

si tu sais poster la solution, ca m'intéresse, j'ai jamais fait ca
 
:jap:
 
J'ai acheté le bouquin de log4j et ca fait 2 semaines que j'attends que le poste me l'envoie :fou:
 
:sweat:


Message édité par darklord le 12-02-2004 à 11:35:53
Reply

Marsh Posté le 12-02-2004 à 12:32:52    

Voici les classes dont je parlais:
 
Exception "encapsulante" permettant de faire l'association exception <-> code d'erreur
 

Code :
  1. package xxx.exceptions;
  3. /**
  4. * Exception générique destinée à la journalisation Tivoli, caractérisée par un code
  5. * d'erreur passé au constructeur de la classe.
  6. *
  7. * Cette exception enveloppe une autre exception (l'exception mère)
  8. */
  9. public class TivoliException extends Exception {
  11. // Attribut privé contenant l'exception mère de cette exception
  12. private Throwable cause = null;
  14. // Code d'erreur associé à l'exception
  15. private int errorCode;
  17. /**
  18.  * Constructeur
  19.  * <br>
  20.  * @param errorCode
  21.  */
  22. public TivoliException(int errorCode) {
  23.  super();
  24.  this.errorCode = errorCode;
  25. }
  27. /**
  28.  * Constructeur
  29.  * <br>
  30.  * Method TivoliException.
  31.  * @param errorCode
  32.  * @param cause
  33.  */
  34. public TivoliException(int errorCode, Throwable cause) {
  35.  this(errorCode);
  36.  this.cause = cause;
  37. }
  39. /**
  40.  * Method getCause.
  41.  * Retourne l'exception mère de cette exception
  42.  * @return Throwable
  43.  */
  44. public Throwable getCause() {
  45.  return cause;
  46. }
  48. /**
  49.  * Method getErrorCode.
  50.  * Retourne le code d'erreur associé à cette exception
  51.  * @return int
  52.  */
  53. public int getErrorCode() {
  54.  return errorCode;
  55. }
  57. /**
  58.  * @see java.lang.Throwable#printStackTrace()
  59.  */
  60. public void printStackTrace() {
  61.  System.err.println("ErrorCode: " + getErrorCode());
  62.  if (cause != null) {
  63.   cause.printStackTrace();
  64.  }
  65. }
  67. /**
  68.  * @see java.lang.Throwable#printStackTrace(PrintStream)
  69.  */
  70. public void printStackTrace(java.io.PrintStream ps) {
  71.  ps.println("ErrorCode: " + getErrorCode());
  72.  if (cause != null) {
  73.   cause.printStackTrace(ps);
  74.  }
  75. }
  77. /**
  78.  * @see java.lang.Throwable#printStackTrace(PrintWriter)
  79.  */
  80. public void printStackTrace(java.io.PrintWriter pw) {
  81.  pw.println("ErrorCode: " + getErrorCode());
  82.  if (cause != null) {
  83.   cause.printStackTrace(pw);
  84.  }
  85. }
  86. }


 
Classe de type Layout spécialisée pour appeler le PatternParser qui va bien...
 

Code :
  1. /*
  2. * Created on 12 févr. 2004
  3. */
  4. package org.apache.log4j;
  6. import org.apache.log4j.helpers.PatternParser;
  7. import org.apache.log4j.helpers.TivoliPatternParser;
  9. /**
  10. * Layout spécialisé afin de gérer le code d'erreur spécifique à une
  11. * exception de type TivoliException
  12. *  
  13. * Date: 12 févr. 2004
  14. */
  15. public class TivoliPatternLayout extends PatternLayout {
  17. public TivoliPatternLayout() {
  18.  super();
  19. }
  21. public TivoliPatternLayout(String pattern) {
  22.  super(pattern);
  23. }
  25. /* (non-Javadoc)
  26.  * @see org.apache.log4j.PatternLayout#createPatternParser(java.lang.String)
  27.  */
  28. protected PatternParser createPatternParser(String pattern) {
  29.  return new TivoliPatternParser(pattern);
  30. }
  32. }


 
Parser spécialisé afin de gérer le joker ("%E" ) qui appelle le code d'erreur d'une TivoliException
 

Code :
  1. /*
  2. * Created on 12 févr. 2004
  3. */
  4. package org.apache.log4j.helpers;
  6. import org.apache.log4j.spi.LoggingEvent;
  7. import org.apache.log4j.spi.ThrowableInformation;
  9. import xxx.exceptions.TivoliException;
  11. /**
  12. * Parser de pattern capable de gérer le joker spécifique au code d'erreur (%E)
  13. * d'une exception
  14. *   
  15. * Date: 12 févr. 2004
  16. */
  17. public class TivoliPatternParser extends PatternParser {
  19. /**
  20.  * Constructeur
  21.  *  
  22.  * @param pattern
  23.  */
  24. public TivoliPatternParser(String pattern) {
  25.  super(pattern);
  26. }
  28. /* (non-Javadoc)
  29.  * @see org.apache.log4j.helpers.PatternParser#finalizeConverter(char)
  30.  */
  31. protected void finalizeConverter(char c) {
  32.  if (c == 'E') {
  33.   PatternConverter pc = new ErrorCodeConverter();
  34.   currentLiteral.setLength(0);
  35.   addConverter(pc);
  36.  } else {
  37.   super.finalizeConverter(c);
  38.  }
  39. }
  41. // ------------------------------------------------- //
  42. // Classe de génération du texte associé au joker %E //
  43. // ------------------------------------------------- //
  45. private static class ErrorCodeConverter extends PatternConverter {
  47.  ErrorCodeConverter() {
  48.   super();
  49.  }
  51.  public String convert(LoggingEvent event) {
  52.   ThrowableInformation ti = event.getThrowableInformation();
  53.   if (ti != null) {
  54.    Throwable t = ti.getThrowable();
  55.    if ((t != null) && (t instanceof TivoliException)) {
  56.     return Integer.toString(
  57.      ((TivoliException) t).getErrorCode());
  58.    }
  59.   }
  60.   return "";
  61.  }
  62. }
  63. }


 
Classe de test
 

Code :
  1. /*
  2. * Created on 12 févr. 2004
  3. */
  4. package xxx.test;
  6. import org.apache.log4j.ConsoleAppender;
  7. import org.apache.log4j.Logger;
  8. import org.apache.log4j.TivoliPatternLayout;
  10. import xxx.exceptions.TivoliException;
  12. /**
  13. * Classe de test
  14. *   
  15. * Date: 12 févr. 2004
  16. */
  17. public class TivoliExceptionTest {
  19. /** Logger */
  20. private static final Logger logger =
  21.  Logger.getLogger(TivoliExceptionTest.class);
  23. public static void main(String[] args) {
  24.  logger.addAppender(
  25.   new ConsoleAppender(
  26.    new TivoliPatternLayout("%d - %c - %E - %m%n" )));
  28.  logger.info("début" );
  29.  logger.error("Error 1", new RuntimeException("Yep" ));
  30.  logger.error(
  31.   "Error 2",
  32.   new TivoliException(1000, new RuntimeException("Nope" )));
  33.  logger.info("fin" );
  34. }
  35. }


 
J'ai étendu les classes de Log4J car ma 1ère implémentation était dégueulasse. J'avais fait ça dans l'urgence à l'époque !

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed