Pourquoi le niveau TRACE existe-t-il et quand devrais-je l'utiliser plutôt que DEBUG?

Dans Log4J, Slf4J et quelques autres infrastructures de journalisation en Java, vous avez deux niveaux de "développeur" pour la journalisation:

• DÉBOGUER
• TRACE

Je comprends ce que fait DEBUG, car l'explication est claire:

Le niveau DEBUG désigne les événements d’information détaillés qui sont les plus utiles pour déboguer une application.

Mais le niveau TRACE n’est pas très spécifique quant à son cas d’utilisation:

Le niveau TRACE désigne des événements d’information plus détaillés que le DEBUG.

(Source: le JavaDoc log4J )

Cela ne me dit pas comment ni quand utiliser TRACE. Fait intéressant, il ne s’agit pas d’un niveau de gravité défini dans la norme syslog . Googler pour la différence entre TRACE et DEBUG semble seulement revenir "utilisez DEBUG, oh, et il y a TRACE aussi". Je n'ai pas trouvé de cas d'utilisation spécifique pour le niveau TRACE. Le meilleur que j'ai pu trouver était cette ancienne page wiki qui discutait du mérite de l'existence du niveau.

Ceci, en tant qu'architecte, soulève beaucoup de drapeaux et de questions dans ma tête. Si un jeune développeur me demandait d'ajouter TRACE à mon architecture, je le bombarderais de questions:

• Quels sont quelques exemples d’informations à consigner avec TRACE et non avec DEBUG?
• Quel problème spécifique puis-je résoudre en enregistrant ces informations?
• Dans ces exemples, quelles sont les propriétés des informations consignées qui distinguent clairement la journalisation au niveau TRACE plutôt qu'au niveau DEBUG?
• Pourquoi cette information doit-elle passer par l'infrastructure de journalisation?
  • Quels sont les avantages de conserver ces informations dans un journal de bord plutôt que de les utiliser System.out.println?
  • Pourquoi est-il préférable d'utiliser le journal pour cela plutôt que le débogueur?
• Quel serait un exemple canonique de journalisation au niveau TRACE?
  • Quels sont les avantages spécifiques obtenus en enregistrant au niveau de TRACE au lieu de DEBUG dans l'exemple?
  • Pourquoi ces gains sont-ils importants?
  • Inversement: Quels problèmes ai-je évités en me connectant à TRACE au lieu de DEBUG?
  • Comment pourrais-je résoudre ces problèmes? Pourquoi la journalisation au niveau TRACE est-elle meilleure que ces autres solutions?
• Les instructions de journal de niveau TRACE doivent-elles être laissées dans le code de production? Pourquoi?

Mais étant donné qu'il est présent dans la plupart des cadres majeurs, je suppose qu'il est utile pour quelque chose? Alors… à quoi sert TRACE et qu'est-ce qui le distingue de DEBUG?

Quels sont les exemples d’informations à consigner avec TRACE et non avec DEBUG?

Si j'ai un algorithme qui passe par plusieurs étapes, le niveau de trace imprimera des informations sur chacune de ces étapes au niveau le plus précis. Des choses comme les entrées et les sorties littérales de chaque étape.

En général, la trace inclut tout le débogage (tout comme le débogage inclut tous les avertissements et les erreurs).

Quel problème spécifique puis-je résoudre en enregistrant ces informations?

Vous avez besoin de déboguer quelque chose qui fournit en sortie sens trop de données pour se connecter en dehors d'une version spécifique lorsque vous ciblez cette chose particulière et ne se soucient pas des erreurs ou d' autres informations de log (puisque le volume d'informations de trace les obscurcir). Dans certains enregistreurs, vous activerez un certain module au niveau de trace uniquement.

Dans ces exemples, quelles sont les propriétés des informations consignées qui distinguent clairement la journalisation au niveau TRACE plutôt qu'au niveau DEBUG?

En règle générale, la journalisation au niveau de trace ne peut pas être activée pendant une période prolongée car elle dégrade considérablement les performances de l'application et / ou crée une abondance de données de journalisation non viables en raison de contraintes de disque / bande passante.

La journalisation au niveau de débogage peut généralement durer plus longtemps sans rendre l'application inutilisable.

Pourquoi cette information doit-elle passer par l'infrastructure de journalisation?

Ce n'est pas obligé. Certains frameworks ont un tracelogger séparé.

Il finit généralement par se retrouver dans les journaux, car les enregistreurs de tâches et les enregistreurs normaux ont des besoins similaires en ce qui concerne l'écriture sur le disque / le réseau, la gestion des erreurs, la rotation des journaux, etc.

Pourquoi est-il préférable d'utiliser le journal pour cela plutôt que le débogueur?

Parce que le débogueur pourrait ne pas pouvoir se connecter à la machine à problème. Vous n'en savez peut-être pas assez pour savoir même où définir des points d'arrêt ou pour parcourir le code. Vous pourriez ne pas être en mesure de reproduire l'erreur de manière fiable dans un débogueur, utilisez donc les journaux pour la récupérer "si cela se produit".

Mais ce ne sont que des noms. Comme n'importe quel autre label, ce sont juste des noms que les gens mettent sur des choses, et signifient généralement différentes choses pour différentes personnes. Et l'étiquette elle-même est moins importante que les morceaux de viande auxquels elle fait référence.

Notez que slf4j recommande spécifiquement de ne pas utiliser trace ( http://slf4j.org/faq.html#trace ):

En bref, bien que nous découragions toujours l’utilisation du niveau TRACE en raison des alternatives ou parce que, dans de nombreux cas, les demandes de log de niveau TRACE sont une perte de temps, étant donné que les utilisateurs le demandaient sans cesse, nous avons décidé de nous plier à la demande populaire.

Personnellement, je m'attendrais à ce que trace enregistre tout (par exemple, même des trucs comme "entré dans la fonction MyFunc avec les arguments A, B, C au moment Y"). L'inconvénient est que non seulement c'est incroyablement bruyant, mais cela a aussi tendance à causer des problèmes d'espace disque; Je m'attendrais à ce qu'une telle journalisation soit désactivée pendant des opérations normales. L'avantage est que cela vous donne un niveau d'informations similaire à celui que vous obtiendriez en parcourant votre programme, dans les cas où l'attachement d'un débogueur peut s'avérer moins pratique.

En général, je trouve que la trace demande généralement plus d’efforts que les autres approches.

Les niveaux de débogage sont en général entièrement arbitraires et peuvent varier selon les langues, les bibliothèques et les entreprises.

Cela étant dit, voici comment je les ai vus utilisés:

TRACE: utilisé pour montrer le déroulement du programme au niveau logique. Entré dans une fonction? Une déclaration "if" at-elle choisi la branche principale ou la branche "else"? C'est un candidat à la trace. En d'autres termes, la consignation de trace est généralement utilisée pour spécifier "vous êtes ici". Ceci est utile dans le contexte d'autres instructions de journalisation susceptibles de consigner une erreur ou d'autres informations. La journalisation des traces peut vous aider à localiser, dans le code, l'erreur ou tout autre événement enregistré à un niveau différent.

DEBUG: utilisé pour vider l'état de la variable, des codes d'erreur spécifiques, etc. Par exemple: un service Web peut renvoyer le code d'erreur 809214, qui peut être consigné pendant que l'application indique à l'utilisateur que "la communication a échoué". Imaginez un développeur qui reçoit un journal du système d'un utilisateur longtemps après l'erreur et qui se demande " pourquoi l'échec est-il survenu?" c'est une bonne chose de vous connecter au niveau de débogage. Un autre exemple pourrait être le cas, si un bogue persiste en production mais qu’il est difficile à reproduire, enregistre dans le module de dépannage certaines variables ou événements du module compliqué afin d’indiquer aux développeurs l’état du programme lorsque l’erreur se produit pour faciliter le dépannage.

Normalement, l’application doit être configurée pour se connecter à un niveau donné (ou supérieur). Par exemple, la trace est souvent le niveau le plus bas: la journalisation à ce niveau enregistre tout. Le niveau de débogage omettrait la trace mais inclurait les niveaux élevés (par exemple avertissements et erreurs).

L’avantage de séparer les niveaux de journal est de contrôler la quantité enregistrée. Pour une application complexe, la journalisation des traces peut potentiellement consigner une quantité énorme de données, la plupart du temps inutiles. Il est préférable de ne consigner que les informations critiques (peut-être des informations de démarrage, puis uniquement des erreurs), sauf si l’ on essaie de déterminer la cause d’un bogue. De plus, cela n’est généralement utile que dans un environnement de production où les débogueurs et d’autres outils de développement ne sont pas présents.

Il n'y a pas de réelle limite à cela, pas de règles indiquant que vous devez vous connecter d'une certaine manière. Seules les conventions générales que certaines bibliothèques ou applications peuvent suivre ou non.

Je pense que l'excellente réponse de Telastyn peut être résumée comme suit:

• DEBUG la coupe doit pouvoir être utilisée dans la production (mais tend à être toujours normale)
• TRACE l'enregistrement est autorisé à être tel que son utilisation en production (autre que pour une session spécifique / courte) est irréalisable

Voici ma règle de base

error   you need        to do something
warn    you might need  to do something
info    you need        to log this in production
debug   you might need  to log this in production
trace   everything that is happening (no performance concerns)

L’hypothèse sous-jacente est que l’équipe ops

• toujours avoir la production réglée sur les informations de niveau de journalisation
• la production peut être configurée pour un débogage au niveau du journal
• la production n'est jamais définie sur une trace au niveau du journal

Fort de cette hypothèse, voici comment vous, en tant que développeur, pouvez utiliser les niveaux de journalisation ...

Problème n ° 1) ne pas ralentir trop les performances de production

debugrésout # 1. En tant que développeur, vous faites de votre mieux pour équilibrer les informations dont vous pourriez avoir besoin en production et pour ne pas avoir trop de bruit, vous ralentissez la machine. Vous dites "c’est une bonne idée de consigner constamment cela en production (si vous le souhaitez)".

Problème n ° 2) avoir des informations verbeuses pendant le développement

tracerésout le problème # 2. Vous ne vous inquiétez absolument pas de l'impact que cela aurait sur une machine de production, mais vous avez besoin de ces informations dès maintenant pour développer le code. Vous dites "je ne fais aucune promesse que ce soit une bonne idée de toujours enregistrer ces informations dans la production".

Certes, comme d'autres l'ont dit, ces choses sont arbitraires. Assurez-vous simplement que votre équipe de développement (et votre équipe d'opérations / de surveillance, car elles sont également des utilisateurs de votre journalisation), sont d'accord sur quelque chose.

Quel serait un exemple canonique de journalisation au niveau TRACE?

ENTRY / EXIT des journaux d’une méthode. Ces journaux vous aident à suivre le déroulement du programme et ont tendance à être très utiles lorsque:

1. Le programme se bloque brusquement - vous savez exactement à quelle fonction il s’est écrasé en regardant la dernière ligne du journal.

2. Certaines fonctions non autorisées échouent silencieusement en absorbant une exception

Ils garantissent un niveau TRACE séparé plutôt que d'utiliser simplement DEBUG, car l'activation des journaux ENTRY / EXIT pour chaque méthode de votre base de code va générer une quantité énorme de journaux supplémentaires qu'il est déraisonnable de toujours activer , même dans un contexte DEBUG.