forked from AFPy/python-docs-fr
Traduction de howto/logging-cookbook (#1850)
Co-authored-by: Jean Abou-Samra <jean@abou-samra.fr>
This commit is contained in:
parent
28a1fc2581
commit
2fb8b34a03
|
@ -6,17 +6,18 @@ msgstr ""
|
|||
"Project-Id-Version: Python 3\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"POT-Creation-Date: 2022-04-05 10:05+0200\n"
|
||||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||||
"PO-Revision-Date: 2022-04-30 16:34+0200\n"
|
||||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||||
"Language: fr\n"
|
||||
"MIME-Version: 1.0\n"
|
||||
"Content-Type: text/plain; charset=UTF-8\n"
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Last-Translator: \n"
|
||||
"X-Generator: Poedit 2.4.2\n"
|
||||
|
||||
#: howto/logging-cookbook.rst:5
|
||||
msgid "Logging Cookbook"
|
||||
msgstr ""
|
||||
msgstr "Recettes pour la journalisation"
|
||||
|
||||
#: howto/logging-cookbook.rst:0
|
||||
msgid "Author"
|
||||
|
@ -31,10 +32,12 @@ msgid ""
|
|||
"This page contains a number of recipes related to logging, which have been "
|
||||
"found useful in the past."
|
||||
msgstr ""
|
||||
"Cette page contient des recettes relatives à la journalisation qui se sont "
|
||||
"avérées utiles par le passé."
|
||||
|
||||
#: howto/logging-cookbook.rst:15
|
||||
msgid "Using logging in multiple modules"
|
||||
msgstr ""
|
||||
msgstr "Journalisation dans plusieurs modules"
|
||||
|
||||
#: howto/logging-cookbook.rst:17
|
||||
msgid ""
|
||||
|
@ -47,10 +50,18 @@ msgid ""
|
|||
"logger calls to the child will pass up to the parent. Here is a main "
|
||||
"module::"
|
||||
msgstr ""
|
||||
"Deux appels à ``logging.getLogger('unLogger')`` renvoient toujours une "
|
||||
"référence vers le même objet de journalisation. C'est valable à l'intérieur "
|
||||
"d'un module, mais aussi dans des modules différents pour autant que ce soit "
|
||||
"le même processus de l'interpréteur Python. En plus, le code d'une "
|
||||
"application peut définir et configurer une journalisation parente dans un "
|
||||
"module et créer (mais pas configurer) une journalisation fille dans un "
|
||||
"module séparé. Les appels à la journalisation fille passeront alors à la "
|
||||
"journalisation parente. Voici un module principal ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:55
|
||||
msgid "Here is the auxiliary module::"
|
||||
msgstr ""
|
||||
msgstr "Voici un module auxiliaire ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:75
|
||||
msgid "The output looks like this:"
|
||||
|
@ -58,27 +69,33 @@ msgstr "La sortie ressemble à ceci ::"
|
|||
|
||||
#: howto/logging-cookbook.rst:101
|
||||
msgid "Logging from multiple threads"
|
||||
msgstr ""
|
||||
msgstr "Journalisation avec des fils d'exécution multiples"
|
||||
|
||||
#: howto/logging-cookbook.rst:103
|
||||
msgid ""
|
||||
"Logging from multiple threads requires no special effort. The following "
|
||||
"example shows logging from the main (initial) thread and another thread::"
|
||||
msgstr ""
|
||||
"La journalisation avec des fils d'exécution multiples ne requiert pas "
|
||||
"d'effort particulier. L'exemple suivant montre comment journaliser depuis le "
|
||||
"fil principal (c.-à-d. initial) et un autre fil ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:132
|
||||
msgid "When run, the script should print something like the following:"
|
||||
msgstr ""
|
||||
msgstr "À l'exécution, le script doit afficher quelque chose comme ça ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:154
|
||||
msgid ""
|
||||
"This shows the logging output interspersed as one might expect. This "
|
||||
"approach works for more threads than shown here, of course."
|
||||
msgstr ""
|
||||
"Les entrées de journalisation sont entrelacées, comme on pouvait s'y "
|
||||
"attendre. Cette approche fonctionne aussi avec plus de fils que dans "
|
||||
"l'exemple, bien sûr."
|
||||
|
||||
#: howto/logging-cookbook.rst:158
|
||||
msgid "Multiple handlers and formatters"
|
||||
msgstr ""
|
||||
msgstr "Plusieurs gestionnaires et formateurs"
|
||||
|
||||
#: howto/logging-cookbook.rst:160
|
||||
msgid ""
|
||||
|
@ -91,6 +108,15 @@ msgid ""
|
|||
"slight modification to the previous simple module-based configuration "
|
||||
"example::"
|
||||
msgstr ""
|
||||
"Les gestionnaires de journalisation sont des objets Python ordinaires. La "
|
||||
"méthode :meth:`~Logger.addHandler` n'est pas limitée, en nombre minimum ou "
|
||||
"maximum, en gestionnaires que vous pouvez ajouter. Parfois, il peut être "
|
||||
"utile pour une application de journaliser tous les messages quels que soient "
|
||||
"leurs niveaux vers un fichier texte, tout en journalisant les erreurs (et "
|
||||
"plus grave) dans la console. Pour ce faire, configurez simplement les "
|
||||
"gestionnaires de manière adéquate. Les appels de journalisation dans le code "
|
||||
"de l'application resteront les mêmes. Voici une légère modification de "
|
||||
"l'exemple précédent dans une configuration au niveau du module ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:193
|
||||
msgid ""
|
||||
|
@ -98,6 +124,9 @@ msgid ""
|
|||
"All that changed was the addition and configuration of a new handler named "
|
||||
"*fh*."
|
||||
msgstr ""
|
||||
"Notez que le code de « l'application » ignore la multiplicité des "
|
||||
"gestionnaires. Les modifications consistent simplement en l'ajout et la "
|
||||
"configuration d'un nouveau gestionnaire appelé *fh*."
|
||||
|
||||
#: howto/logging-cookbook.rst:196
|
||||
msgid ""
|
||||
|
@ -110,10 +139,19 @@ msgid ""
|
|||
"to happen is to modify the severity level of the logger and/or handler to "
|
||||
"debug."
|
||||
msgstr ""
|
||||
"La possibilité de créer de nouveaux gestionnaires avec des filtres sur un "
|
||||
"niveau de gravité supérieur ou inférieur peut être très utile lors de "
|
||||
"l'écriture ou du test d'une application. Au lieu d'utiliser de nombreuses "
|
||||
"instructions ``print`` pour le débogage, utilisez ``logger.debug`` : "
|
||||
"contrairement aux instructions ``print``, que vous devrez supprimer ou "
|
||||
"commenter plus tard, les instructions ``logger.debug`` peuvent demeurer "
|
||||
"telles quelles dans le code source et restent dormantes jusqu'à ce que vous "
|
||||
"en ayez à nouveau besoin. À ce moment-là, il suffit de modifier le niveau de "
|
||||
"gravité de la journalisation ou du gestionnaire pour déboguer."
|
||||
|
||||
#: howto/logging-cookbook.rst:207
|
||||
msgid "Logging to multiple destinations"
|
||||
msgstr ""
|
||||
msgstr "Journalisation vers plusieurs destinations"
|
||||
|
||||
#: howto/logging-cookbook.rst:209
|
||||
msgid ""
|
||||
|
@ -123,34 +161,46 @@ msgid ""
|
|||
"console. Let's also assume that the file should contain timestamps, but the "
|
||||
"console messages should not. Here's how you can achieve this::"
|
||||
msgstr ""
|
||||
"Supposons que vous souhaitiez journaliser dans la console et dans un fichier "
|
||||
"avec différents formats de messages et avec différents critères. Supposons "
|
||||
"que vous souhaitiez consigner les messages de niveau DEBUG et supérieur dans "
|
||||
"le fichier, et les messages de niveau INFO et supérieur dans la console. "
|
||||
"Supposons également que le fichier doive contenir des horodatages, mais pas "
|
||||
"les messages de la console. Voici comment y parvenir ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:247
|
||||
msgid "When you run this, on the console you will see"
|
||||
msgstr ""
|
||||
msgstr "Quand vous le lancez, vous devez voir"
|
||||
|
||||
#: howto/logging-cookbook.rst:256
|
||||
msgid "and in the file you will see something like"
|
||||
msgstr ""
|
||||
msgstr "et, dans le fichier, vous devez trouver"
|
||||
|
||||
#: howto/logging-cookbook.rst:266
|
||||
msgid ""
|
||||
"As you can see, the DEBUG message only shows up in the file. The other "
|
||||
"messages are sent to both destinations."
|
||||
msgstr ""
|
||||
"Comme vous pouvez le constater, le message DEBUG n'apparaît que dans le "
|
||||
"fichier. Les autres messages sont envoyés vers les deux destinations."
|
||||
|
||||
#: howto/logging-cookbook.rst:269
|
||||
msgid ""
|
||||
"This example uses console and file handlers, but you can use any number and "
|
||||
"combination of handlers you choose."
|
||||
msgstr ""
|
||||
"Cet exemple utilise la console et des gestionnaires de fichier, mais vous "
|
||||
"pouvez utiliser et combiner autant de gestionnaires que de besoin."
|
||||
|
||||
#: howto/logging-cookbook.rst:274
|
||||
msgid "Configuration server example"
|
||||
msgstr ""
|
||||
msgstr "Exemple d'un serveur de configuration"
|
||||
|
||||
#: howto/logging-cookbook.rst:276
|
||||
msgid "Here is an example of a module using the logging configuration server::"
|
||||
msgstr ""
|
||||
"Voici un exemple de module mettant en œuvre la configuration de la "
|
||||
"journalisation *via* un serveur ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:307
|
||||
msgid ""
|
||||
|
@ -158,10 +208,14 @@ msgid ""
|
|||
"server, properly preceded with the binary-encoded length, as the new logging "
|
||||
"configuration::"
|
||||
msgstr ""
|
||||
"Et voici un script qui, à partir d'un nom de fichier, commence par envoyer "
|
||||
"la taille du fichier encodée en binaire (comme il se doit), puis envoie ce "
|
||||
"fichier au serveur pour définir la nouvelle configuration de "
|
||||
"journalisation ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:330
|
||||
msgid "Dealing with handlers that block"
|
||||
msgstr ""
|
||||
msgstr "Utilisation de gestionnaires bloquants"
|
||||
|
||||
#: howto/logging-cookbook.rst:334
|
||||
msgid ""
|
||||
|
@ -169,6 +223,10 @@ msgid ""
|
|||
"blocking the thread you're logging from. This is common in web applications, "
|
||||
"though of course it also occurs in other scenarios."
|
||||
msgstr ""
|
||||
"Parfois, il est nécessaire que les gestionnaires de journalisation fassent "
|
||||
"leur travail sans bloquer le fil d'exécution qui émet des événements. C'est "
|
||||
"généralement le cas dans les applications Web, mais aussi bien sûr dans "
|
||||
"d'autres scénarios."
|
||||
|
||||
#: howto/logging-cookbook.rst:338
|
||||
msgid ""
|
||||
|
@ -180,6 +238,15 @@ msgid ""
|
|||
"which is too slow (and this query can be deep in the socket library code, "
|
||||
"below the Python layer, and outside your control)."
|
||||
msgstr ""
|
||||
"Un gestionnaire classiquement lent est le :class:`SMTPHandler` : l'envoi d'e-"
|
||||
"mails peut prendre beaucoup de temps, pour un certain nombre de raisons "
|
||||
"indépendantes du développeur (par exemple, une infrastructure de messagerie "
|
||||
"ou de réseau peu performante). Mais n'importe quel autre gestionnaire "
|
||||
"utilisant le réseau ou presque peut aussi s'avérer bloquant : même une "
|
||||
"simple opération :class:`SocketHandler` peut faire une requête DNS implicite "
|
||||
"et être ainsi très lente (cette requête peut être enfouie profondément dans "
|
||||
"le code de la bibliothèque d'accès réseau, sous la couche Python, et hors de "
|
||||
"votre contrôle)."
|
||||
|
||||
#: howto/logging-cookbook.rst:346
|
||||
msgid ""
|
||||
|
@ -194,6 +261,18 @@ msgid ""
|
|||
"to attach only ``QueueHandlers`` to your loggers) for the benefit of other "
|
||||
"developers who will use your code."
|
||||
msgstr ""
|
||||
"Une solution consiste à utiliser une approche en deux parties. Pour la "
|
||||
"première partie, affectez un seul :class:`QueueHandler` à la journalisation "
|
||||
"des fils d'exécution critiques pour les performances. Ils écrivent "
|
||||
"simplement dans leur file d'attente, qui peut être dimensionnée à une "
|
||||
"capacité suffisamment grande ou initialisée sans limite supérieure en "
|
||||
"taille. L'écriture dans la file d'attente est généralement acceptée "
|
||||
"rapidement, mais nous vous conseillons quand même de prévoir d'intercepter "
|
||||
"l'exception :exc:`queue.Full` par précaution dans votre code. Si vous "
|
||||
"développez une bibliothèque avec des fils d'exécution critiques pour les "
|
||||
"performances, documentez-le bien (avec une suggestion de n'affecter que des "
|
||||
"``QueueHandlers`` à votre journalisation) pour faciliter le travail des "
|
||||
"développeurs qui utilisent votre code."
|
||||
|
||||
#: howto/logging-cookbook.rst:357
|
||||
msgid ""
|
||||
|
@ -205,6 +284,13 @@ msgid ""
|
|||
"matter). The ``LogRecords`` are removed from the queue and passed to the "
|
||||
"handlers for processing."
|
||||
msgstr ""
|
||||
"La deuxième partie de la solution est la classe :class:`QueueListener`, "
|
||||
"conçue comme l'homologue de :class:`QueueHandler`. Un :class:`QueueListener` "
|
||||
"est très simple : vous lui passez une file d'attente et des gestionnaires, "
|
||||
"et il lance un fil d'exécution interne qui scrute la file d'attente pour "
|
||||
"récupérer les événements envoyés par les ``QueueHandlers`` (ou toute autre "
|
||||
"source de ``LogRecords``, d'ailleurs). Les ``LogRecords`` sont supprimés de "
|
||||
"la file d'attente et transmis aux gestionnaires pour traitement."
|
||||
|
||||
#: howto/logging-cookbook.rst:365
|
||||
msgid ""
|
||||
|
@ -214,14 +300,20 @@ msgid ""
|
|||
"handler classes, which would eat up one thread per handler for no particular "
|
||||
"benefit."
|
||||
msgstr ""
|
||||
"L'avantage d'avoir une classe :class:`QueueListener` séparée est que vous "
|
||||
"pouvez utiliser la même instance pour servir plusieurs ``QueueHandlers``. "
|
||||
"Cela consomme moins de ressources que des instances de gestionnaires "
|
||||
"réparties chacune dans un fil d'exécution séparé."
|
||||
|
||||
#: howto/logging-cookbook.rst:370
|
||||
msgid "An example of using these two classes follows (imports omitted)::"
|
||||
msgstr ""
|
||||
"Voici un exemple d'utilisation de ces deux classes (les importations sont "
|
||||
"omises) ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:388
|
||||
msgid "which, when run, will produce:"
|
||||
msgstr ""
|
||||
msgstr "ce qui produit ceci à l'exécution :"
|
||||
|
||||
#: howto/logging-cookbook.rst:394
|
||||
msgid ""
|
||||
|
@ -234,10 +326,18 @@ msgid ""
|
|||
"of each message with the handler's level, and only passes a message to a "
|
||||
"handler if it's appropriate to do so."
|
||||
msgstr ""
|
||||
"Avant Python 3.5, la classe :class:`QueueListener` passait chaque message "
|
||||
"reçu de la file d'attente à chaque gestionnaire avec lequel l'instance avait "
|
||||
"été initialisée (on supposait que le filtrage de niveau était entièrement "
|
||||
"effectué de l'autre côté, au niveau de l'alimentation de la file d'attente). "
|
||||
"Depuis Python 3.5, le comportement peut être modifié en passant l'argument "
|
||||
"par mot-clé ``respect_handler_level=True`` au constructeur. Dans ce cas, la "
|
||||
"``QueueListener`` compare le niveau de chaque message avec le niveau défini "
|
||||
"dans chaque gestionnaire et ne transmet le message que si c'est opportun."
|
||||
|
||||
#: howto/logging-cookbook.rst:407
|
||||
msgid "Sending and receiving logging events across a network"
|
||||
msgstr ""
|
||||
msgstr "Envoi et réception d'événements de journalisation à travers le réseau"
|
||||
|
||||
#: howto/logging-cookbook.rst:409
|
||||
msgid ""
|
||||
|
@ -245,18 +345,26 @@ msgid ""
|
|||
"at the receiving end. A simple way of doing this is attaching a :class:"
|
||||
"`SocketHandler` instance to the root logger at the sending end::"
|
||||
msgstr ""
|
||||
"Supposons que vous souhaitiez envoyer des événements de journalisation sur "
|
||||
"un réseau et les traiter à la réception. Une façon simple de faire est "
|
||||
"d'attacher une instance :class:`SocketHandler` à la journalisation racine de "
|
||||
"l'émetteur ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:437
|
||||
msgid ""
|
||||
"At the receiving end, you can set up a receiver using the :mod:"
|
||||
"`socketserver` module. Here is a basic working example::"
|
||||
msgstr ""
|
||||
"Vous pouvez configurer le récepteur en utilisant le module :mod:"
|
||||
"`socketserver`. Voici un exemple élémentaire ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:525
|
||||
msgid ""
|
||||
"First run the server, and then the client. On the client side, nothing is "
|
||||
"printed on the console; on the server side, you should see something like:"
|
||||
msgstr ""
|
||||
"Lancez d'abord le serveur, puis le client. Côté client, rien ne s'affiche "
|
||||
"sur la console ; côté serveur, vous devez voir quelque chose comme ça :"
|
||||
|
||||
#: howto/logging-cookbook.rst:537
|
||||
msgid ""
|
||||
|
@ -266,10 +374,16 @@ msgid ""
|
|||
"implementing your alternative there, as well as adapting the above script to "
|
||||
"use your alternative serialization."
|
||||
msgstr ""
|
||||
"Notez que ``pickle`` introduit des problèmes de sécurité dans certains "
|
||||
"scénarios. Si vous êtes concerné, vous pouvez utiliser une sérialisation "
|
||||
"alternative en surchargeant la méthode :meth:`~handlers.SocketHandler."
|
||||
"makePickle` par votre propre implémentation, ainsi qu'en adaptant le script "
|
||||
"ci-dessus pour utiliser votre sérialisation."
|
||||
|
||||
#: howto/logging-cookbook.rst:545
|
||||
msgid "Running a logging socket listener in production"
|
||||
msgstr ""
|
||||
"Journalisation en production à l'aide d'un connecteur en écoute sur le réseau"
|
||||
|
||||
#: howto/logging-cookbook.rst:547
|
||||
msgid ""
|
||||
|
@ -280,11 +394,19 @@ msgid ""
|
|||
"using Supervisor: you will need to change the `/path/to/` parts in the Gist "
|
||||
"to reflect the actual paths you want to use."
|
||||
msgstr ""
|
||||
"Pour de la journalisation en production *via* un connecteur réseau en "
|
||||
"écoute, il est probable que vous ayez besoin d'utiliser un outil de "
|
||||
"surveillance tel que `Supervisor <http://supervisord.org/>`_. Vous trouverez "
|
||||
"dans ce `Gist <https://gist.github.com/"
|
||||
"vsajip/4b227eeec43817465ca835ca66f75e2b>`_ des gabarits pour assurer cette "
|
||||
"fonction avec *Supervisor* : vous aurez besoin de modifier les parties `/"
|
||||
"path/to/` du *Gist* pour refléter les chemins réels que vous utilisez."
|
||||
|
||||
#: howto/logging-cookbook.rst:558
|
||||
msgid "Adding contextual information to your logging output"
|
||||
msgstr ""
|
||||
msgstr "Ajout d'informations contextuelles dans la journalisation"
|
||||
|
||||
# #no-qa
|
||||
#: howto/logging-cookbook.rst:560
|
||||
msgid ""
|
||||
"Sometimes you want logging output to contain contextual information in "
|
||||
|
@ -300,10 +422,26 @@ msgid ""
|
|||
"logging an application, it could be hard to manage if the number of :class:"
|
||||
"`Logger` instances becomes effectively unbounded."
|
||||
msgstr ""
|
||||
"Dans certains cas, vous pouvez souhaiter que la journalisation contienne des "
|
||||
"informations contextuelles en plus des paramètres transmis à l'appel de "
|
||||
"journalisation. Par exemple, dans une application réseau, il peut être "
|
||||
"souhaitable de consigner des informations spécifiques au client dans le "
|
||||
"journal (par exemple, le nom d'utilisateur ou l'adresse IP du client "
|
||||
"distant). Bien que vous puissiez utiliser le paramètre *extra* pour y "
|
||||
"parvenir, il n'est pas toujours pratique de transmettre les informations de "
|
||||
"cette manière. Il peut être aussi tentant de créer des instances :class:"
|
||||
"`Logger` connexion par connexion, mais ce n'est pas une bonne idée car ces "
|
||||
"instances :class:`Logger` ne sont pas éliminées par le ramasse-miettes. Même "
|
||||
"si ce point n'est pas problématique en soi si la journalisation est "
|
||||
"configurée avec plusieurs niveaux de granularité, cela peut devenir "
|
||||
"difficile de gérer un nombre potentiellement illimité d'instances de :class:"
|
||||
"`Logger`."
|
||||
|
||||
#: howto/logging-cookbook.rst:575
|
||||
msgid "Using LoggerAdapters to impart contextual information"
|
||||
msgstr ""
|
||||
"Utilisation d'adaptateurs de journalisation pour transmettre des "
|
||||
"informations contextuelles"
|
||||
|
||||
#: howto/logging-cookbook.rst:577
|
||||
msgid ""
|
||||
|
@ -315,6 +453,14 @@ msgid ""
|
|||
"signatures as their counterparts in :class:`Logger`, so you can use the two "
|
||||
"types of instances interchangeably."
|
||||
msgstr ""
|
||||
"Un moyen simple de transmettre des informations contextuelles accompagnant "
|
||||
"les informations de journalisation consiste à utiliser la classe :class:"
|
||||
"`LoggerAdapter`. Cette classe est conçue pour ressembler à un :class:"
|
||||
"`Logger`, de sorte que vous pouvez appeler :meth:`debug`, :meth:`info`, :"
|
||||
"meth:`warning`, :meth:`error`, :meth:`exception`, :meth:`critical` et :meth:"
|
||||
"`log`. Ces méthodes ont les mêmes signatures que leurs homologues dans :"
|
||||
"class:`Logger`, vous pouvez donc utiliser les deux types d'instances de "
|
||||
"manière interchangeable."
|
||||
|
||||
#: howto/logging-cookbook.rst:585
|
||||
msgid ""
|
||||
|
@ -326,6 +472,13 @@ msgid ""
|
|||
"contextual information in the delegated call. Here's a snippet from the code "
|
||||
"of :class:`LoggerAdapter`::"
|
||||
msgstr ""
|
||||
"Lorsque vous créez une instance de :class:`LoggerAdapter`, vous lui "
|
||||
"transmettez une instance de :class:`Logger` et un objet dictionnaire qui "
|
||||
"contient vos informations contextuelles. Lorsque vous appelez l'une des "
|
||||
"méthodes de journalisation sur une instance de :class:`LoggerAdapter`, elle "
|
||||
"délègue l'appel à l'instance sous-jacente de :class:`Logger` transmise à son "
|
||||
"constructeur et s'arrange pour intégrer les informations contextuelles dans "
|
||||
"l'appel délégué. Voici un extrait du code de :class:`LoggerAdapter` ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:601
|
||||
msgid ""
|
||||
|
@ -339,6 +492,15 @@ msgid ""
|
|||
"had passed an 'extra' keyword argument in the call to the adapter, it will "
|
||||
"be silently overwritten."
|
||||
msgstr ""
|
||||
"Les informations contextuelles sont ajoutées dans la méthode :meth:"
|
||||
"`~LoggerAdapter.process` de :class:`LoggerAdapter`. On lui passe le message "
|
||||
"et les arguments par mot-clé de l'appel de journalisation, et elle en "
|
||||
"renvoie des versions (potentiellement) modifiées à utiliser pour la "
|
||||
"journalisation sous-jacente. L'implémentation par défaut de cette méthode "
|
||||
"laisse le message seul, mais insère une clé ``extra`` dans l'argument par "
|
||||
"mot-clé dont la valeur est l'objet dictionnaire passé au constructeur. Bien "
|
||||
"sûr, si vous avez passé un argument par mot-clé ``extra`` dans l'appel à "
|
||||
"l'adaptateur, il est écrasé silencieusement."
|
||||
|
||||
#: howto/logging-cookbook.rst:610
|
||||
msgid ""
|
||||
|
@ -350,20 +512,33 @@ msgid ""
|
|||
"string, you just need to subclass :class:`LoggerAdapter` and override :meth:"
|
||||
"`~LoggerAdapter.process` to do what you need. Here is a simple example::"
|
||||
msgstr ""
|
||||
"L'avantage d'utiliser ``extra`` est que les valeurs de l'objet dictionnaire "
|
||||
"sont fusionnées dans le ``__dict__`` de l'instance :class:`LogRecord`, ce "
|
||||
"qui vous permet d'utiliser des chaînes personnalisées avec vos instances :"
|
||||
"class:`Formatter` qui connaissent les clés de l'objet dictionnaire. Si vous "
|
||||
"avez besoin d'une méthode différente, par exemple si vous souhaitez ajouter "
|
||||
"des informations contextuelles avant ou après la chaîne de message, il vous "
|
||||
"suffit de surcharger :class:`LoggerAdapter` et de remplacer :meth:"
|
||||
"`~LoggerAdapter.process` pour faire ce dont vous avez besoin. Voici un "
|
||||
"exemple simple ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:626
|
||||
msgid "which you can use like this::"
|
||||
msgstr ""
|
||||
msgstr "que vous pouvez utiliser comme ceci ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:631
|
||||
msgid ""
|
||||
"Then any events that you log to the adapter will have the value of "
|
||||
"``some_conn_id`` prepended to the log messages."
|
||||
msgstr ""
|
||||
"Ainsi, tout événement journalisé aura la valeur de ``some_conn_id`` insérée "
|
||||
"en début de message de journalisation."
|
||||
|
||||
#: howto/logging-cookbook.rst:635
|
||||
msgid "Using objects other than dicts to pass contextual information"
|
||||
msgstr ""
|
||||
"Utilisation d'objets autres que les dictionnaires pour passer des "
|
||||
"informations contextuelles"
|
||||
|
||||
#: howto/logging-cookbook.rst:637
|
||||
msgid ""
|
||||
|
@ -373,10 +548,16 @@ msgid ""
|
|||
"if you want to generate values dynamically (whereas the values in a dict "
|
||||
"would be constant)."
|
||||
msgstr ""
|
||||
"Il n'est pas obligatoire de passer un dictionnaire réel à un :class:"
|
||||
"`LoggerAdapter`, vous pouvez passer une instance d'une classe qui implémente "
|
||||
"``__getitem__`` et ``__iter__`` pour qu'il ressemble à un dictionnaire du "
|
||||
"point de vue de la journalisation. C'est utile si vous souhaitez générer des "
|
||||
"valeurs de manière dynamique (alors que les valeurs d'un dictionnaire "
|
||||
"seraient constantes)."
|
||||
|
||||
#: howto/logging-cookbook.rst:646
|
||||
msgid "Using Filters to impart contextual information"
|
||||
msgstr ""
|
||||
msgstr "Utilisation de filtres pour transmettre des informations contextuelles"
|
||||
|
||||
#: howto/logging-cookbook.rst:648
|
||||
msgid ""
|
||||
|
@ -386,6 +567,12 @@ msgid ""
|
|||
"can then be output using a suitable format string, or if needed a custom :"
|
||||
"class:`Formatter`."
|
||||
msgstr ""
|
||||
"Un :class:`Filter` défini par l'utilisateur peut aussi ajouter des "
|
||||
"informations contextuelles à la journalisation. Les instances de ``Filter`` "
|
||||
"sont autorisées à modifier les ``LogRecords`` qui leur sont transmis, y "
|
||||
"compris par l'ajout d'attributs supplémentaires qui peuvent ensuite être "
|
||||
"intégrés à la journalisation en utilisant une chaîne de formatage appropriée "
|
||||
"ou, si nécessaire, un :class:`Formatter` personnalisé."
|
||||
|
||||
#: howto/logging-cookbook.rst:653
|
||||
msgid ""
|
||||
|
@ -398,14 +585,23 @@ msgid ""
|
|||
"format string can be used to get similar output to that shown above. Here's "
|
||||
"an example script::"
|
||||
msgstr ""
|
||||
"Par exemple, dans une application Web, la requête en cours de traitement (ou "
|
||||
"du moins ce qu'elle contient d'intéressant) peut être stockée dans une "
|
||||
"variable locale au fil d'exécution (:class:`threading.local`), puis utilisée "
|
||||
"dans un ``Filter`` pour ajouter, par exemple, des informations relatives à "
|
||||
"la requête (par exemple, l'adresse IP distante et le nom de l'utilisateur) "
|
||||
"au ``LogRecord``, en utilisant les noms d'attribut ``ip`` et ``user`` comme "
|
||||
"dans l'exemple ``LoggerAdapter`` ci-dessus. Dans ce cas, la même chaîne de "
|
||||
"formatage peut être utilisée pour obtenir une sortie similaire à celle "
|
||||
"indiquée ci-dessus. Voici un exemple de script ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:699
|
||||
msgid "which, when run, produces something like:"
|
||||
msgstr ""
|
||||
msgstr "qui, à l'exécution, produit quelque chose comme ça ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:720
|
||||
msgid "Logging to a single file from multiple processes"
|
||||
msgstr ""
|
||||
msgstr "Journalisation vers un fichier unique à partir de plusieurs processus"
|
||||
|
||||
#: howto/logging-cookbook.rst:722
|
||||
msgid ""
|
||||
|
@ -422,6 +618,20 @@ msgid ""
|
|||
"includes a working socket receiver which can be used as a starting point for "
|
||||
"you to adapt in your own applications."
|
||||
msgstr ""
|
||||
"La journalisation est fiable avec les programmes à fils d'exécution "
|
||||
"multiples (thread-safe) : rien n'empêche plusieurs fils d'exécution de "
|
||||
"journaliser dans le même fichier, du moment que ces fils d'exécution font "
|
||||
"partie du même processus. En revanche, il n'existe aucun moyen standard de "
|
||||
"sérialiser l'accès à un seul fichier sur plusieurs processus en Python. Si "
|
||||
"vous avez besoin de vous connecter à un seul fichier à partir de plusieurs "
|
||||
"processus, une façon de le faire est de faire en sorte que tous les "
|
||||
"processus se connectent à un :class:`~handlers.SocketHandler`, et d'avoir un "
|
||||
"processus séparé qui implémente un serveur qui lit à partir de ce connecteur "
|
||||
"et écrit les journaux dans le fichier (si vous préférez, vous pouvez dédier "
|
||||
"un fil d'exécution dans l'un des processus existants pour exécuter cette "
|
||||
"tâche). :ref:`Cette section <network-logging>` documente cette approche plus "
|
||||
"en détail et inclut un connecteur en écoute réseau fonctionnel qui peut être "
|
||||
"utilisé comme point de départ pour l'adapter à vos propres applications."
|
||||
|
||||
#: howto/logging-cookbook.rst:735
|
||||
msgid ""
|
||||
|
@ -433,6 +643,14 @@ msgid ""
|
|||
"`multiprocessing` module does not provide working lock functionality on all "
|
||||
"platforms (see https://bugs.python.org/issue3770)."
|
||||
msgstr ""
|
||||
"Vous pouvez également écrire votre propre gestionnaire en utilisant la "
|
||||
"classe :class:`~multiprocessing.Lock` du module :mod:`multiprocessing` pour "
|
||||
"sérialiser l'accès au fichier depuis vos processus. Les actuels :class:"
|
||||
"`FileHandler` et sous-classes n'utilisent pas :mod:`multiprocessing` pour le "
|
||||
"moment, même s'ils pourraient le faire à l'avenir. Notez qu'à l'heure "
|
||||
"actuelle, le module :mod:`multiprocessing` ne fournit pas un verrouillage "
|
||||
"fonctionnel pour toutes les plates-formes (voir https://bugs.python.org/"
|
||||
"issue3770)."
|
||||
|
||||
#: howto/logging-cookbook.rst:745
|
||||
msgid ""
|
||||
|
@ -448,12 +666,26 @@ msgid ""
|
|||
"application, and can be used as the basis for code meeting your own specific "
|
||||
"requirements::"
|
||||
msgstr ""
|
||||
"Autrement, vous pouvez utiliser une ``Queue`` et un :class:`QueueHandler` "
|
||||
"pour envoyer tous les événements de journalisation à l'un des processus de "
|
||||
"votre application multi-processus. L'exemple de script suivant montre "
|
||||
"comment procéder ; dans l'exemple, un processus d'écoute distinct écoute les "
|
||||
"événements envoyés par les autres processus et les journalise en fonction de "
|
||||
"sa propre configuration de journalisation. Bien que l'exemple ne montre "
|
||||
"qu'une seule façon de faire (par exemple, vous pouvez utiliser un fil "
|
||||
"d'exécution d'écoute plutôt qu'un processus d'écoute séparé – "
|
||||
"l'implémentation serait analogue), il permet des configurations de "
|
||||
"journalisation complètement différentes pour celui qui écoute ainsi que pour "
|
||||
"les autres processus de votre application, et peut être utilisé comme base "
|
||||
"pour répondre à vos propres exigences ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:861
|
||||
msgid ""
|
||||
"A variant of the above script keeps the logging in the main process, in a "
|
||||
"separate thread::"
|
||||
msgstr ""
|
||||
"Une variante du script ci-dessus conserve la journalisation dans le "
|
||||
"processus principal, dans un fil séparé ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:956
|
||||
msgid ""
|
||||
|
@ -464,10 +696,17 @@ msgid ""
|
|||
"events are generated in the worker processes) to direct the messages to the "
|
||||
"appropriate destinations."
|
||||
msgstr ""
|
||||
"Cette variante montre comment appliquer la configuration pour des "
|
||||
"enregistreurs particuliers - par exemple l'enregistreur ``foo`` a un "
|
||||
"gestionnaire spécial qui stocke tous les événements du sous-système ``foo`` "
|
||||
"dans un fichier ``mplog-foo.log``. C'est utilisé par le mécanisme de "
|
||||
"journalisation dans le processus principal (même si les événements de "
|
||||
"journalisation sont générés dans les processus de travail) pour diriger les "
|
||||
"messages vers les destinations appropriées."
|
||||
|
||||
#: howto/logging-cookbook.rst:963
|
||||
msgid "Using concurrent.futures.ProcessPoolExecutor"
|
||||
msgstr ""
|
||||
msgstr "Utilisation de concurrent.futures.ProcessPoolExecutor"
|
||||
|
||||
#: howto/logging-cookbook.rst:965
|
||||
msgid ""
|
||||
|
@ -475,22 +714,29 @@ msgid ""
|
|||
"your worker processes, you need to create the queue slightly differently. "
|
||||
"Instead of"
|
||||
msgstr ""
|
||||
"Si vous souhaitez utiliser :class:`concurrent.futures.ProcessPoolExecutor` "
|
||||
"pour démarrer vos processus de travail, vous devez créer la file d'attente "
|
||||
"légèrement différemment. À la place de"
|
||||
|
||||
#: howto/logging-cookbook.rst:973
|
||||
msgid "you should use"
|
||||
msgstr ""
|
||||
msgstr "vous devez écrire"
|
||||
|
||||
#: howto/logging-cookbook.rst:979
|
||||
msgid "and you can then replace the worker creation from this::"
|
||||
msgstr ""
|
||||
"et vous pouvez alors remplacer la création du processus de travail telle "
|
||||
"que ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:990
|
||||
msgid "to this (remembering to first import :mod:`concurrent.futures`)::"
|
||||
msgstr ""
|
||||
"par celle-ci (souvenez-vous d'importer au préalable :mod:`concurrent."
|
||||
"futures`) ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:997
|
||||
msgid "Deploying Web applications using Gunicorn and uWSGI"
|
||||
msgstr ""
|
||||
msgstr "Déploiement d'applications Web avec *Gunicorn* et *uWSGI*"
|
||||
|
||||
#: howto/logging-cookbook.rst:999
|
||||
msgid ""
|
||||
|
@ -503,10 +749,20 @@ msgid ""
|
|||
"process management tool such as Supervisor - see `Running a logging socket "
|
||||
"listener in production`_ for more details."
|
||||
msgstr ""
|
||||
"Lors du déploiement d'applications Web qui utilisent `Gunicorn <https://"
|
||||
"gunicorn.org/>`_ ou `uWSGI <https://uwsgi-docs.readthedocs.io/en/latest/>`_ "
|
||||
"(ou équivalent), plusieurs processus de travail sont créés pour traiter les "
|
||||
"requêtes des clients. Dans de tels environnements, évitez de créer des "
|
||||
"gestionnaires à fichiers directement dans votre application Web. Au lieu de "
|
||||
"cela, utilisez un :class:`SocketHandler` pour journaliser depuis "
|
||||
"l'application Web vers gestionnaire réseau à l'écoute dans un processus "
|
||||
"séparé. Cela peut être configuré à l'aide d'un outil de gestion de processus "
|
||||
"tel que *Supervisor* (voir `Journalisation en production à l'aide d'un "
|
||||
"connecteur en écoute sur le réseau`_ pour plus de détails)."
|
||||
|
||||
#: howto/logging-cookbook.rst:1009
|
||||
msgid "Using file rotation"
|
||||
msgstr ""
|
||||
msgstr "Utilisation du roulement de fichiers"
|
||||
|
||||
#: howto/logging-cookbook.rst:1014
|
||||
msgid ""
|
||||
|
@ -517,12 +773,21 @@ msgid ""
|
|||
"usage pattern, the logging package provides a :class:`~handlers."
|
||||
"RotatingFileHandler`::"
|
||||
msgstr ""
|
||||
"Parfois, vous souhaitez laisser un fichier de journalisation grossir jusqu'à "
|
||||
"une certaine taille, puis ouvrir un nouveau fichier et vous y enregistrer "
|
||||
"les nouveaux événements. Vous souhaitez peut-être conserver un certain "
|
||||
"nombre de ces fichiers et, lorsque ce nombre de fichiers aura été créé, "
|
||||
"faire rouler les fichiers afin que le nombre de fichiers et la taille des "
|
||||
"fichiers restent tous deux limités. Pour ce cas d'usage, :class:`~handlers."
|
||||
"RotatingFileHandler` est inclus dans le paquet de journalisation ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:1046
|
||||
msgid ""
|
||||
"The result should be 6 separate files, each with part of the log history for "
|
||||
"the application:"
|
||||
msgstr ""
|
||||
"Vous devez obtenir 6 fichiers séparés, chacun contenant une partie de "
|
||||
"l'historique de journalisation de l'application :"
|
||||
|
||||
#: howto/logging-cookbook.rst:1058
|
||||
msgid ""
|
||||
|
@ -531,16 +796,23 @@ msgid ""
|
|||
"``.1``. Each of the existing backup files is renamed to increment the suffix "
|
||||
"(``.1`` becomes ``.2``, etc.) and the ``.6`` file is erased."
|
||||
msgstr ""
|
||||
"Le fichier de journalisation actuel est toujours :file:"
|
||||
"`logging_rotatingfile_example.out`, et chaque fois qu'il atteint la taille "
|
||||
"limite, il est renommé avec le suffixe ``.1``. Chacun des fichiers de "
|
||||
"sauvegarde existants est renommé pour incrémenter le suffixe (``.1`` devient "
|
||||
"``.2``, etc.) et le fichier ``.6`` est effacé."
|
||||
|
||||
#: howto/logging-cookbook.rst:1063
|
||||
msgid ""
|
||||
"Obviously this example sets the log length much too small as an extreme "
|
||||
"example. You would want to set *maxBytes* to an appropriate value."
|
||||
msgstr ""
|
||||
"De toute évidence, la longueur du journal définie dans cet exemple est "
|
||||
"beaucoup trop petite. À vous de définir *maxBytes* à une valeur appropriée."
|
||||
|
||||
#: howto/logging-cookbook.rst:1069
|
||||
msgid "Use of alternative formatting styles"
|
||||
msgstr ""
|
||||
msgstr "Utilisation d'autres styles de formatage"
|
||||
|
||||
#: howto/logging-cookbook.rst:1071
|
||||
msgid ""
|
||||
|
@ -550,6 +822,11 @@ msgid ""
|
|||
"`string.Template` (added in Python 2.4) and :meth:`str.format` (added in "
|
||||
"Python 2.6)."
|
||||
msgstr ""
|
||||
"Lorsque la journalisation a été ajoutée à la bibliothèque standard Python, "
|
||||
"la seule façon de formater les messages avec un contenu variable était "
|
||||
"d'utiliser la méthode de formatage avec « % ». Depuis, Python s'est enrichi "
|
||||
"de deux nouvelles méthode de formatage : :class:`string.Template` (ajouté "
|
||||
"dans Python 2.4) et :meth:`str.format` (ajouté dans Python 2.6)."
|
||||
|
||||
#: howto/logging-cookbook.rst:1077
|
||||
msgid ""
|
||||
|
@ -563,6 +840,17 @@ msgid ""
|
|||
"meth:`str.format` or :class:`string.Template`. Here's an example console "
|
||||
"session to show the possibilities:"
|
||||
msgstr ""
|
||||
"La journalisation (à partir de la version 3.2) offre une meilleure prise en "
|
||||
"charge de ces deux styles de formatage supplémentaires. La classe :class:"
|
||||
"`Formatter` a été améliorée pour accepter un paramètre par mot-clé "
|
||||
"facultatif supplémentaire nommé ``style``. La valeur par défaut est ``'%'``, "
|
||||
"les autres valeurs possibles étant ``'{'`` et ``'$'``, qui correspondent aux "
|
||||
"deux autres styles de formatage. La rétrocompatibilité est maintenue par "
|
||||
"défaut (comme vous vous en doutez) mais, en spécifiant explicitement un "
|
||||
"paramètre de style, vous avez la possibilité de spécifier des chaînes de "
|
||||
"format qui fonctionnent avec :meth:`str.format` ou :class:`string.Template`. "
|
||||
"Voici un exemple de session interactive en console pour montrer les "
|
||||
"possibilités :"
|
||||
|
||||
#: howto/logging-cookbook.rst:1111
|
||||
msgid ""
|
||||
|
@ -570,6 +858,10 @@ msgid ""
|
|||
"completely independent of how an individual logging message is constructed. "
|
||||
"That can still use %-formatting, as shown here::"
|
||||
msgstr ""
|
||||
"Notez que le formatage des messages de journalisation est, au final, "
|
||||
"complètement indépendant de la façon dont un message de journalisation "
|
||||
"individuel est construit. Vous pouvez toujours utiliser formatage *via* "
|
||||
"« % », comme ici ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:1119
|
||||
msgid ""
|
||||
|
@ -586,6 +878,19 @@ msgid ""
|
|||
"logging calls which are out there in existing code will be using %-format "
|
||||
"strings."
|
||||
msgstr ""
|
||||
"Les appels de journalisation (``logger.debug()``, ``logger.info()`` etc.) ne "
|
||||
"prennent que des paramètres positionnels pour le message de journalisation "
|
||||
"lui-même, les paramètres par mots-clés étant utilisés uniquement pour "
|
||||
"déterminer comment gérer le message réel (par exemple, le paramètre par mot-"
|
||||
"clé ``exc_info`` indique que les informations de trace doivent être "
|
||||
"enregistrées, ou le paramètre par mot-clé ``extra`` indique des informations "
|
||||
"contextuelles supplémentaires à ajouter au journal). Vous ne pouvez donc pas "
|
||||
"inclure dans les appels de journalisation à l'aide de la syntaxe :meth:`str."
|
||||
"format` ou :class:`string.Template`, car le paquet de journalisation utilise "
|
||||
"le formatage via « % » en interne pour fusionner la chaîne de format et les "
|
||||
"arguments de variables. Il n'est pas possible de changer ça tout en "
|
||||
"préservant la rétrocompatibilité puisque tous les appels de journalisation "
|
||||
"dans le code pré-existant utilisent des chaînes au format « % »."
|
||||
|
||||
#: howto/logging-cookbook.rst:1132
|
||||
msgid ""
|
||||
|
@ -595,6 +900,11 @@ msgid ""
|
|||
"will call ``str()`` on that object to get the actual format string. Consider "
|
||||
"the following two classes::"
|
||||
msgstr ""
|
||||
"Il existe cependant un moyen d'utiliser le formatage *via* « {} » et « $ » "
|
||||
"pour vos messages de journalisation. Rappelez-vous que, pour un message, "
|
||||
"vous pouvez utiliser un objet arbitraire comme chaîne de format de message, "
|
||||
"et que le package de journalisation appelle ``str()`` sur cet objet pour "
|
||||
"fabriquer la chaîne finale. Considérez les deux classes suivantes ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:1156
|
||||
msgid ""
|
||||
|
@ -606,6 +916,14 @@ msgid ""
|
|||
"__ (double underscore --- not to be confused with _, the single underscore "
|
||||
"used as a synonym/alias for :func:`gettext.gettext` or its brethren)."
|
||||
msgstr ""
|
||||
"L'une ou l'autre peut être utilisée à la place d'une chaîne de format "
|
||||
"\"%(message)s\" ou \"{message}\" ou \"$message\", afin de mettre en forme "
|
||||
"*via* « { } » ou « $ » la partie « message réel » qui apparaît dans la "
|
||||
"sortie de journal formatée. Il est un peu lourd d'utiliser les noms de "
|
||||
"classe chaque fois que vous voulez journaliser quelque chose, mais ça "
|
||||
"devient acceptable si vous utilisez un alias tel que __ (double trait de "
|
||||
"soulignement — à ne pas confondre avec _, le trait de soulignement unique "
|
||||
"utilisé comme alias pour :func:`gettext.gettext` ou ses homologues)."
|
||||
|
||||
#: howto/logging-cookbook.rst:1164
|
||||
msgid ""
|
||||
|
@ -613,6 +931,10 @@ msgid ""
|
|||
"copy and paste into your own code. They can be used as follows (assuming "
|
||||
"that they're declared in a module called ``wherever``):"
|
||||
msgstr ""
|
||||
"Les classes ci-dessus ne sont pas incluses dans Python, bien qu'elles soient "
|
||||
"assez faciles à copier et coller dans votre propre code. Elles peuvent être "
|
||||
"utilisées comme suit (en supposant qu'elles soient déclarées dans un module "
|
||||
"appelé ``wherever``) :"
|
||||
|
||||
#: howto/logging-cookbook.rst:1186
|
||||
msgid ""
|
||||
|
@ -620,6 +942,9 @@ msgid ""
|
|||
"you would of course use ``logger.debug()`` or similar to actually log using "
|
||||
"this approach."
|
||||
msgstr ""
|
||||
"Alors que les exemples ci-dessus utilisent ``print()`` pour montrer comment "
|
||||
"fonctionne le formatage, utilisez bien sûr ``logger.debug()`` ou similaire "
|
||||
"pour journaliser avec cette approche."
|
||||
|
||||
#: howto/logging-cookbook.rst:1190
|
||||
msgid ""
|
||||
|
@ -631,18 +956,31 @@ msgid ""
|
|||
"not just the format string. That's because the __ notation is just syntax "
|
||||
"sugar for a constructor call to one of the XXXMessage classes."
|
||||
msgstr ""
|
||||
"Une chose à noter est qu'il n'y a pas de perte de performance significative "
|
||||
"avec cette approche : le formatage réel ne se produit pas lorsque vous "
|
||||
"effectuez l'appel de journalisation, mais lorsque (et si) le message "
|
||||
"journalisé est réellement sur le point d'être écrit dans un journal par un "
|
||||
"gestionnaire. Ainsi, la seule chose légèrement inhabituelle qui pourrait "
|
||||
"vous perturber est que les parenthèses entourent la chaîne de format et les "
|
||||
"arguments, pas seulement la chaîne de format. C'est parce que la notation __ "
|
||||
"n'est que du sucre syntaxique pour un appel de constructeur à l'une des "
|
||||
"classes `XXXMessage`."
|
||||
|
||||
#: howto/logging-cookbook.rst:1198
|
||||
msgid ""
|
||||
"If you prefer, you can use a :class:`LoggerAdapter` to achieve a similar "
|
||||
"effect to the above, as in the following example::"
|
||||
msgstr ""
|
||||
"Si vous préférez, vous pouvez utiliser un :class:`LoggerAdapter` pour "
|
||||
"obtenir un effet similaire à ce qui précède, comme dans l'exemple suivant ::"
|
||||
|
||||
#: howto/logging-cookbook.rst:1229
|
||||
msgid ""
|
||||
"The above script should log the message ``Hello, world!`` when run with "
|
||||
"Python 3.2 or later."
|
||||
msgstr ""
|
||||
"Le script ci-dessus journalise le message ``Hello, world!`` quand il est "
|
||||
"lancé avec Python 3.2 ou ultérieur."
|
||||
|
||||
#: howto/logging-cookbook.rst:1238
|
||||
msgid "Customizing ``LogRecord``"
|
||||
|
|
Loading…
Reference in New Issue
Block a user