# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-03-22 22:16+0100\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\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"

#: howto/logging-cookbook.rst:5

msgid "Logging Cookbook"

msgstr "Recettes pour la journalisation"

#: howto/logging-cookbook.rst:0

msgid "Author"

msgstr "Auteur"

#: howto/logging-cookbook.rst:7

msgid "Vinay Sajip <vinay_sajip at red-dove dot com>"

msgstr "Vinay Sajip <vinay_sajip at red-dove dot com>"

#: howto/logging-cookbook.rst:9

msgid ""

"This page contains a number of recipes related to logging, which have been "

"found useful in the past."

msgstr ""

#: howto/logging-cookbook.rst:15

msgid "Using logging in multiple modules"

msgstr "Journalisation dans plusieurs modules"

#: howto/logging-cookbook.rst:17

msgid ""

"Multiple calls to ``logging.getLogger('someLogger')`` return a reference to "

"the same logger object. This is true not only within the same module, but "

"also across modules as long as it is in the same Python interpreter "

"process. It is true for references to the same object; additionally, "

"application code can define and configure a parent logger in one module and "

"create (but not configure) a child logger in a separate module, and all "

"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 "Voici un module auxiliaire ::"

#: howto/logging-cookbook.rst:75

msgid "The output looks like this:"

msgstr "La sortie ressemble à ceci ::"

#: howto/logging-cookbook.rst:101

msgid "Logging from multiple threads"

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 "À 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 "Plusieurs gestionnaires et formateurs"

#: howto/logging-cookbook.rst:160

msgid ""

"Loggers are plain Python objects. The :meth:`~Logger.addHandler` method has "

"no minimum or maximum quota for the number of handlers you may add. "

"Sometimes it will be beneficial for an application to log all messages of "

"all severities to a text file while simultaneously logging errors or above "

"to the console. To set this up, simply configure the appropriate handlers. "

"The logging calls in the application code will remain unchanged. Here is a "

"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 ""

"Notice that the 'application' code does not care about multiple handlers. "

"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 ""

"The ability to create new handlers with higher- or lower-severity filters "

"can be very helpful when writing and testing an application. Instead of "

"using many ``print`` statements for debugging, use ``logger.debug``: Unlike "

"the print statements, which you will have to delete or comment out later, "

"the logger.debug statements can remain intact in the source code and remain "

"dormant until you need them again. At that time, the only change that needs "

"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 "Journalisation vers plusieurs destinations"

#: howto/logging-cookbook.rst:209

msgid ""

"Let's say you want to log to console and file with different message formats "

"and in differing circumstances. Say you want to log messages with levels of "

"DEBUG and higher to file, and those messages at level INFO and higher to the "

"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 "Quand vous le lancez, vous devez voir"

#: howto/logging-cookbook.rst:256

msgid "and in the file you will see something like"

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 "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 ""

"And here is a script that takes a filename and sends that file to the "

"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 "Utilisation de gestionnaires bloquants"

#: howto/logging-cookbook.rst:334

msgid ""

"Sometimes you have to get your logging handlers to do their work without "

"blocking the thread you're logging from. This is common in Web applications, "

"though of course it also occurs in other scenarios."

msgstr ""

#: howto/logging-cookbook.rst:338

msgid ""

"A common culprit which demonstrates sluggish behaviour is the :class:"

"`SMTPHandler`: sending emails can take a long time, for a number of reasons "

"outside the developer's control (for example, a poorly performing mail or "

"network infrastructure). But almost any network-based handler can block: "

"Even a :class:`SocketHandler` operation may do a DNS query under the hood "

"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 ""

"One solution is to use a two-part approach. For the first part, attach only "

"a :class:`QueueHandler` to those loggers which are accessed from performance-"

"critical threads. They simply write to their queue, which can be sized to a "

"large enough capacity or initialized with no upper bound to their size. The "

"write to the queue will typically be accepted quickly, though you will "

"probably need to catch the :exc:`queue.Full` exception as a precaution in "

"your code. If you are a library developer who has performance-critical "

"threads in their code, be sure to document this (together with a suggestion "

"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 ""

"The second part of the solution is :class:`QueueListener`, which has been "

"designed as the counterpart to :class:`QueueHandler`. A :class:"

"`QueueListener` is very simple: it's passed a queue and some handlers, and "

"it fires up an internal thread which listens to its queue for LogRecords "

"sent from ``QueueHandlers`` (or any other source of ``LogRecords``, for that "

"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 ""

"The advantage of having a separate :class:`QueueListener` class is that you "

"can use the same instance to service multiple ``QueueHandlers``. This is "

"more resource-friendly than, say, having threaded versions of the existing "

"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 "ce qui produit ceci à l’exécution :"

#: howto/logging-cookbook.rst:394

msgid ""

"Prior to Python 3.5, the :class:`QueueListener` always passed every message "

"received from the queue to every handler it was initialized with. (This was "

"because it was assumed that level filtering was all done on the other side, "

"where the queue is filled.) From 3.5 onwards, this behaviour can be changed "

"by passing a keyword argument ``respect_handler_level=True`` to the "

"listener's constructor. When this is done, the listener compares the level "

"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 "Envoi et réception d’événements de journalisation à travers le réseau"

#: howto/logging-cookbook.rst:409

msgid ""

"Let's say you want to send logging events across a network, and handle them "

"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 ""

"Note that there are some security issues with pickle in some scenarios. If "

"these affect you, you can use an alternative serialization scheme by "

"overriding the :meth:`~handlers.SocketHandler.makePickle` method and "

"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 ""

"To run a logging listener in production, you may need to use a process-"

"management tool such as `Supervisor <http://supervisord.org/>`_. `Here "

"<https://gist.github.com/vsajip/4b227eeec43817465ca835ca66f75e2b>`_ is a "

"Gist which provides the bare-bones files to run the above functionality "

"using Supervisor: you will need to change the `/path/to/` parts in the Gist "

"to reflect the actual paths you want to use."

msgstr ""

#: howto/logging-cookbook.rst:558

msgid "Adding contextual information to your logging output"

msgstr "Ajout d’informations contextuelles dans la journalisation"

#: howto/logging-cookbook.rst:560

msgid ""

"Sometimes you want logging output to contain contextual information in "

"addition to the parameters passed to the logging call. For example, in a "

"networked application, it may be desirable to log client-specific "

"information in the log (e.g. remote client's username, or IP address). "

"Although you could use the *extra* parameter to achieve this, it's not "

"always convenient to pass the information in this way. While it might be "

"tempting to create :class:`Logger` instances on a per-connection basis, this "

"is not a good idea because these instances are not garbage collected. While "

"this is not a problem in practice, when the number of :class:`Logger` "

"instances is dependent on the level of granularity you want to use in "

"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 ""

"An easy way in which you can pass contextual information to be output along "

"with logging event information is to use the :class:`LoggerAdapter` class. "

"This class is designed to look like a :class:`Logger`, so that you can call :"

"meth:`debug`, :meth:`info`, :meth:`warning`, :meth:`error`, :meth:"

"`exception`, :meth:`critical` and :meth:`log`. These methods have the same "

"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 ""

"When you create an instance of :class:`LoggerAdapter`, you pass it a :class:"

"`Logger` instance and a dict-like object which contains your contextual "

"information. When you call one of the logging methods on an instance of :"

"class:`LoggerAdapter`, it delegates the call to the underlying instance of :"

"class:`Logger` passed to its constructor, and arranges to pass the "

"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 ""

"The :meth:`~LoggerAdapter.process` method of :class:`LoggerAdapter` is where "

"the contextual information is added to the logging output. It's passed the "

"message and keyword arguments of the logging call, and it passes back "

"(potentially) modified versions of these to use in the call to the "

"underlying logger. The default implementation of this method leaves the "

"message alone, but inserts an 'extra' key in the keyword argument whose "

"value is the dict-like object passed to the constructor. Of course, if you "

"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 ""

"The advantage of using 'extra' is that the values in the dict-like object "

"are merged into the :class:`LogRecord` instance's __dict__, allowing you to "

"use customized strings with your :class:`Formatter` instances which know "

"about the keys of the dict-like object. If you need a different method, e.g. "

"if you want to prepend or append the contextual information to the message "

"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 "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 ""

"You don't need to pass an actual dict to a :class:`LoggerAdapter` - you "

"could pass an instance of a class which implements ``__getitem__`` and "

"``__iter__`` so that it looks like a dict to logging. This would be useful "

"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 "Utilisation de filtres pour transmettre des informations contextuelles"

#: howto/logging-cookbook.rst:648

msgid ""

"You can also add contextual information to log output using a user-defined :"

"class:`Filter`. ``Filter`` instances are allowed to modify the "

"``LogRecords`` passed to them, including adding additional attributes which "

"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 ""

"For example in a web application, the request being processed (or at least, "

"the interesting parts of it) can be stored in a threadlocal (:class:"

"`threading.local`) variable, and then accessed from a ``Filter`` to add, "

"say, information from the request - say, the remote IP address and remote "

"user's username - to the ``LogRecord``, using the attribute names 'ip' and "

"'user' as in the ``LoggerAdapter`` example above. In that case, the same "

"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 "qui, à l’exécution, produit quelque chose comme ça ::"

#: howto/logging-cookbook.rst:720

msgid "Logging to a single file from multiple processes"

msgstr "Journalisation vers un fichier unique à partir de plusieurs processus"

#: howto/logging-cookbook.rst:722

msgid ""

"Although logging is thread-safe, and logging to a single file from multiple "

"threads in a single process *is* supported, logging to a single file from "

"*multiple processes* is *not* supported, because there is no standard way to "

"serialize access to a single file across multiple processes in Python. If "

"you need to log to a single file from multiple processes, one way of doing "

"this is to have all the processes log to a :class:`~handlers.SocketHandler`, "

"and have a separate process which implements a socket server which reads "

"from the socket and logs to file. (If you prefer, you can dedicate one "

"thread in one of the existing processes to perform this function.) :ref:"

"`This section <network-logging>` documents this approach in more detail and "

"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 ""

"You could also write your own handler which uses the :class:"

"`~multiprocessing.Lock` class from the :mod:`multiprocessing` module to "

"serialize access to the file from your processes. The existing :class:"

"`FileHandler` and subclasses do not make use of :mod:`multiprocessing` at "

"present, though they may do so in the future. Note that at present, the :mod:"

"`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 ""

"Alternatively, you can use a ``Queue`` and a :class:`QueueHandler` to send "

"all logging events to one of the processes in your multi-process "

"application. The following example script demonstrates how you can do this; "

"in the example a separate listener process listens for events sent by other "

"processes and logs them according to its own logging configuration. Although "

"the example only demonstrates one way of doing it (for example, you may want "

"to use a listener thread rather than a separate listener process -- the "

"implementation would be analogous) it does allow for completely different "

"logging configurations for the listener and the other processes in your "

"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 ""

"This variant shows how you can e.g. apply configuration for particular "

"loggers - e.g. the ``foo`` logger has a special handler which stores all "

"events in the ``foo`` subsystem in a file ``mplog-foo.log``. This will be "

"used by the logging machinery in the main process (even though the logging "

"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 "Utilisation de concurrent.futures.ProcessPoolExecutor"

#: howto/logging-cookbook.rst:965

msgid ""

"If you want to use :class:`concurrent.futures.ProcessPoolExecutor` to start "

"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 "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 "Déploiement d’applications Web avec *Gunicorn* et *uWSGI*"

#: howto/logging-cookbook.rst:999

msgid ""

"When deploying Web applications using `Gunicorn <https://gunicorn.org/>`_ or "

"`uWSGI <https://uwsgi-docs.readthedocs.io/en/latest/>`_ (or similar), "

"multiple worker processes are created to handle client requests. In such "

"environments, avoid creating file-based handlers directly in your web "

"application. Instead, use a :class:`SocketHandler` to log from the web "

"application to a listener in a separate process. This can be set up using a "

"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 "Utilisation du roulement de fichiers"

#: howto/logging-cookbook.rst:1014

msgid ""

"Sometimes you want to let a log file grow to a certain size, then open a new "

"file and log to that. You may want to keep a certain number of these files, "

"and when that many files have been created, rotate the files so that the "

"number of files and the size of the files both remain bounded. For this "

"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 ""

"The most current file is always :file:`logging_rotatingfile_example.out`, "

"and each time it reaches the size limit it is renamed with the suffix "

"``.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 "Utilisation d’autres styles de formatage"

#: howto/logging-cookbook.rst:1071

msgid ""

"When logging was added to the Python standard library, the only way of "

"formatting messages with variable content was to use the %-formatting "

"method. Since then, Python has gained two new formatting approaches: :class:"

"`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 ""

"Logging (as of 3.2) provides improved support for these two additional "

"formatting styles. The :class:`Formatter` class been enhanced to take an "

"additional, optional keyword parameter named ``style``. This defaults to "

"``'%'``, but other possible values are ``'{'`` and ``'$'``, which correspond "

"to the other two formatting styles. Backwards compatibility is maintained by "

"default (as you would expect), but by explicitly specifying a style "

"parameter, you get the ability to specify format strings which work with :"

"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 ""

"Note that the formatting of logging messages for final output to logs is "

"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 ""

"Logging calls (``logger.debug()``, ``logger.info()`` etc.) only take "

"positional parameters for the actual logging message itself, with keyword "

"parameters used only for determining options for how to handle the actual "

"logging call (e.g. the ``exc_info`` keyword parameter to indicate that "

"traceback information should be logged, or the ``extra`` keyword parameter "

"to indicate additional contextual information to be added to the log). So "

"you cannot directly make logging calls using :meth:`str.format` or :class:"

"`string.Template` syntax, because internally the logging package uses %-"

"formatting to merge the format string and the variable arguments. There "

"would be no changing this while preserving backward compatibility, since all "

"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 ""

"There is, however, a way that you can use {}- and $- formatting to construct "

"your individual log messages. Recall that for a message you can use an "

"arbitrary object as a message format string, and that the logging package "

"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 ""

"Either of these can be used in place of a format string, to allow {}- or $-"

"formatting to be used to build the actual \"message\" part which appears in "

"the formatted log output in place of \"%(message)s\" or \"{message}\" or "

"\"$message\". It's a little unwieldy to use the class names whenever you "

"want to log something, but it's quite palatable if you use an alias such as "

"__ (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 ""

"The above classes are not included in Python, though they're easy enough to "

"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 ""

"While the above examples use ``print()`` to show how the formatting works, "

"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 ""

"One thing to note is that you pay no significant performance penalty with "

"this approach: the actual formatting happens not when you make the logging "

"call, but when (and if) the logged message is actually about to be output to "

"a log by a handler. So the only slightly unusual thing which might trip you "

"up is that the parentheses go around the format string and the arguments, "

"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``"

msgstr "Personnalisation de ``LogRecord``"

#: howto/logging-cookbook.rst:1240

msgid ""

"Every logging event is represented by a :class:`LogRecord` instance. When an "

"event is logged and not filtered out by a logger's level, a :class:"

"`LogRecord` is created, populated with information about the event and then "

"passed to the handlers for that logger (and its ancestors, up to and "

"including the logger where further propagation up the hierarchy is "

"disabled). Before Python 3.2, there were only two places where this creation "

"was done:"

msgstr ""

"Chaque événement de journalisation est représenté par une instance :class:"

"`LogRecord`. Lorsqu’un événement est enregistré et non filtré en raison du "

"niveau d’un enregistreur, un :class:`LogRecord` est créé, rempli avec les "

"informations de l’événement, puis transmis aux gestionnaires de cet "

"enregistreur (et ses ancêtres, jusqu’à et y compris l’enregistreur où la "

"propagation vers le haut de la hiérarchie est désactivée). Avant Python 3.2, "

"il n’y avait que deux endroits où cette création était effectuée :"

#: howto/logging-cookbook.rst:1247

msgid ""

":meth:`Logger.makeRecord`, which is called in the normal process of logging "

"an event. This invoked :class:`LogRecord` directly to create an instance."

msgstr ""

":meth:`Logger.makeRecord`, qui est appelée dans le processus normal de "

"journalisation d’un événement. Elle appelait :class:`LogRecord` directement "

"pour créer une instance."