Python JSON Logging

La journalisation nous permet de suivre les événements qui se produisent pendant que certains logiciels fonctionnent. Lorsque le logiciel échoue et que nous n'avons aucun enregistrement de journalisation, il y a très peu de possibilités que nous déterminons la racine du problème. Mais avec les enregistrements de journalisation, nous pouvons maintenir tous les échecs. Bien que, lorsqu'un système doit analyser les journaux qui ne suivent pas un modèle ou un module prédéfini, les choses se compliquent. Python contient donc JSON qui organise les données de manière formatée à l'aide d'objets qui adhèrent à un modèle spécifié. Le Python-Json-Logger est le module de journalisation Python standard qui affiche les événements de journal en tant qu'objet JSON. Le module JSON Logger améliore la lisibilité à la machine de nos journaux et empêche la création des analyseurs uniques pour les entrées du type Syslog.

Comment utiliser la journalisation JSON Python?

La bibliothèque «python_json_logger» est requise pour les journaux au format JSON. Nous pouvons installer cette bibliothèque Python avec la commande PIP. Ce qui suit est la commande pour l'installer. Lorsqu'il est installé, l'invite affiche également le message de confirmation avec la version récente de la bibliothèque.

PIP installe Python-Json-Logger

Exemple 1:

L'utilisation de base du module de journalisation est relativement simple et peut être utilisée pour enregistrer les événements dans des fichiers. Ici, nous fournissons d'abord l'implémentation simple de la journalisation Python. Nous créons le journal et le configurons à l'aide de la méthode BasicConfig (). Cette méthode prend le nom du fichier où les journaux sont créés car le fichier donné est ouvert en mode écriture «W». Le format est également défini pour les journaux. Ensuite, nous déclarons l'objet «Enregistreur» où avec la méthode getlogger (). Nous retournons le bûcheron avec le nom attribué.

Ensuite, le niveau de l'enregistreur est ajusté via la méthode SetLevel () pour servir de seuil de suivi pour le débogage qui est basé sur les valeurs numériques qui sont allouées à chaque niveau. Après cela, nous déployons certaines méthodes de classe d'enregistrement, y compris le message particulier en tant que paramètre. La méthode debug () imprime le message de débogage. La méthode info () génère un message qui est connecté à ce journal. Ensuite, la méthode critique () montre le niveau critique de l'enregistreur donné. Les méthodes d'avertissement () et d'erreur () montrent l'avertissement pour l'enregistreur et toute exception soulevée par l'enregistreur.

journalisation d'importation
enregistrement.BasicConfig (filename = "newfile.enregistrer",
format = '% (asctime) s% (message) s', fileMode = 'w')
Logger = journalisation.getlogger ()
bûcheron.Setlevel (journalisation.DÉBOGUER)
bûcheron.Debug ("Décog sécurisé")
bûcheron.info ("c'est une information")
bûcheron.avertissement ("génère l'avertissement")
bûcheron.Erreur ("L'erreur se produit i.e lors de la division par zéro ")
bûcheron.critique ("la connexion Internet est lente")

Le programme crée un fichier avec le prénom. Lorsque nous ouvrons le fichier, il contient les informations par rapport à chaque méthode d'enregistrement spécifiée qui est répertoriée dans les éléments suivants:

Exemple 2:

Dans le programme susmentionné, nous avons la fonctionnalité de journalisation Python. Maintenant, nous avons un programme où la bibliothèque Python JSON Logger est utilisée pour stocker les journaux au format JSON à l'aide des méthodes de journalisation intégrées. Ici, nous commençons le code de journalisation JSON Python en insérant le module de journalisation et le module JSONLogger pour la classe PythonjsonLogger. Après cela, nous déclarons l'objet «format» qui est défini avec la méthode JSONFormatter () pour obtenir les résultats au format JSON. Ensuite, nous définissons l'objet "JSON_HANDLER" pour invoquer la méthode FileHandler () qui donne le fichier JSON fourni.

Ensuite, nous définissons le format pour le fichier JSON à l'aide de la méthode setFormatter () où l'objet de format est passé comme entrée. Ensuite, nous obtenons l'objet de l'enregistreur de la méthode getlogger (). Le "JSON_HANDLER" est ajouté via la méthode AddHandler (). En fin de compte, l'enregistreur.La méthode error () qui rencontre une erreur du format JSON est soulevée ici.

journalisation d'importation
de Pythonjsonlogger import Jsonlogger
format = jsonlogger.JSONFormatter ()
json_handler = journalisation.Filehandler (filename = 'newlog.JSON ')
JSON_HANDLER.setFormatter (formatter)
Logger = journalisation.getlogger ('my_json')
bûcheron.AddHandler (json_handler)
bûcheron.Erreur ('une erreur rencontrée', extra = 'type': 'fatal')

Le journal JSON suivant est créé dans le «Newlog.Fichier JSON "lorsque nous l'ouvrirons à partir du module JSONLogger de Python:

Exemple 3:

Le format de journal JSON de base est donné dans l'exemple précédent. Maintenant, nous démontrons l'exception et le trace de la mise en forme de la connexion à JSON à l'aide du module JSONLogger. Les tracebacks donnent des informations spécifiques sur l'échec du programme, donc les enregistrer est souvent précieuse. Nous pouvons utiliser la journalisation.Méthode d'exception qui est un module de journalisation Python intégré pour enregistrer les erreurs et ajouter nos messages d'erreur personnalisés.

De plus, l'exploitation forestière.La méthode exception () a une gravité par défaut d'erreur. Tout d'abord, nous utilisons l'instruction d'importation du chargement du module de journalisation et du module JSONLogger pour les journaux JSON. Après cela, nous créons l'instance du journal à l'aide de la méthode getLogger () pour accéder au journal. L'exception du journal et le trace sont manipulées et générées dans le «BadcalculationDemo.Fichier JSON ".

Ensuite, nous fournissons la méthode jsonformatter () dans l'objet «Formatter» pour formater les journaux dans la structure JSON et définir le formateur fourni avec le setFormatter. Ensuite, nous ajoutons le gestionnaire «Loghandlerjson» créé à la méthode AddHandler (). Le bloc d'essai à l'exception est utilisé pour attraper les journaux à partir du Traceback suivant. Ici, nous avons une déclaration d'essai où l'entier est divisé par la valeur de la chaîne qui est une mauvaise pratique de calcul. L'instruction sauf attrape cette exception de journal dans l'exploitation forestière.exception () qui imprime le message fourni avec un rapport de trace dans le format JSON au badcalculationdemo.fichier json.

journalisation d'importation
de Pythonjsonlogger import Jsonlogger
Mylogger = journalisation.getlogger ()
Loghandlerjson = journalisation.FileHandler ("BadcalculationDemo.JSON ")
format = jsonlogger.JSONFormatter ()
Logandlerjson.setFormatter (formatter)
Mylogger.AddHandler (Loghandlerjson)
essayer:
1 / "lait"
sauf:
enregistrement.Exception («Votre calcul était mauvais»)

Lorsque le script est exécuté, un objet JSON Strificié apparaît dans le badcalculationdemo.Le contenu du fichier JSON. Ce qui suit est l'image du badmathdemo.Fichier JSON qui affiche le message d'erreur avec les informations de trace:

Exemple 4:

Les attributs avec les caractères spécifiques à JSON pourraient faire corrompre l'objet JSON. Nous pouvons personnaliser le système de journalisation unique à l'aide de la classe Formatter et permettre au module JSON d'échapper de manière appropriée à tous les attributs. Ici, nous fournissons la journalisation JSON personnalisée qui fournit les attributs supplémentaires pour les événements des journaux. Nous insérons les modules JSON, Logging et SYS pour créer les événements de journal de notre système. Ensuite, nous établissons la classe «JSONFormatter» qui prend la journalisation d'entrée et le formateur comme paramètres. Après cela, nous créons les attributs «auto» et «enregistrements» pour cette classe.

Ensuite, nous générons l'objet «supplémentaire» où la méthode getAttr () est appelée pour accéder à la journalisation.Attributs LogRecord au format JSON. L'enregistrement JSON est utilisé pour obtenir l'heure, le nom de niveau, le nom de fichier, le numéro de ligne et le message fourni pour le journal du système.

De plus, nous extrassons également des détails supplémentaires concernant les journaux système. Ensuite, nous utilisons le JSON.Méthode Dump () où l'objet Python "JSON_Record" est passé pour la conversion en l'objet JSON. Les attributs JSON de Python sont configurés à partir de la définition de la méthode jsonconfig (). La technique IF-Else est utilisée pour créer le gestionnaire personnalisé qui donne les journaux dans le fichier spécifié ou la forme du flux de sortie vers la console. Le journal root est configuré avec le gestionnaire personnalisé. Ensuite, nous invoquons la méthode jsonconfig () et la méthode de journalisation qui donne le niveau des messages de journal sous forme de JSON.

Importer JSON, journalisation, sys
classe JSONFormatter (journalisation.Formateur):
format def (self, disque):
extra = getAttr (enregistrer, "__dict__", )
json_record =
"Temps": Extra.obtenir ("défini"),
"Niveau": getAttr (enregistrement, "niveau de niveau", aucun),
"Fichier": getAttr (enregistrer, "nom de fichier", aucun),
"Ligne": getAttr (enregistrer, "lineno", aucun),
"Msg": getAttr (enregistrer, "msg", aucun),
"Additional_Detail": Extra.get ("supplémentaire_detail"),

retourner JSON.Dumps (json_record)
def JSONConfig (filename = Aucun):
Si le nom de fichier:
Handler = journalisation.FileHandler (nom de fichier)
autre:
Handler = journalisation.StreamHandler (sys.stdout)
maître.setFormatter (jsonFormatter ())
enregistrement.getlogger ().AddHandler (gestionnaire)
JSONConfig ()
enregistrement.getlogger ().Setlevel (journalisation.DÉBOGUER)
enregistrement.Debug ("Exemple de Python")
enregistrement.AVERTISSEMENT ("JSON Logging", extra = "Additional_Detail": 999)

Le script de journalisation JSON Python génère la sortie des dictionnaires JSON suivants:

Conclusion

La meilleure façon d'organiser les journaux et de centraliser leur visualisation est avec Python JSON Logging et un programme de gestion des journaux. Pour formater et obtenir les détails les plus pertinents, nous devons également examiner les procédures de journalisation Python. Il est important de se faire informer de nos restrictions Python JSON Log car ils pourraient nous empêcher de faire une contribution significative. L'événement de journalisation sous forme d'objets JSON est bien meilleur que le texte simple. À l'aide d'un langage de requête basé sur JSON, il est simple d'ajouter les enregistrements aux bases de données à l'aide du format JSON.