From 4cde77721fbe72b089b7d1c2addedc6c41bbdc1d Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Wed, 13 Apr 2022 22:56:36 +0200 Subject: [PATCH 1/6] Traduction de howto/logging-cookbook --- howto/logging-cookbook.po | 390 +++++++++++++++++++++++++++++++++++--- 1 file changed, 365 insertions(+), 25 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index e3422127d..3d3a57929 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -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 \n" +"PO-Revision-Date: 2022-04-13 22:55+0200\n" "Language-Team: FRENCH \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 "" +"Plusieurs appels à ``logging.getLogger('unLogger')`` renvoient 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 formatteurs" #: 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 pour 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 `_. Vous trouverez " +"dans ce `Gist `_ 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,25 @@ msgid "" "logging an application, it could be hard to manage if the number of :class:" "`Logger` instances becomes effectively unbounded." msgstr "" +"Parfois, vous souhaitez 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, gérer un nombre potentiellement illimité " +"d'instances de :class:`Logger`, qui dépend du niveau de granularité souhaité " +"pour la journalisation, peut être difficile." #: 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 +452,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 +471,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 +491,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 renvoie " +"des versions (potentiellement) modifiées de ceux-ci à 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 +511,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 +547,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 +566,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 format appropriée " +"ou, si nécessaire, un :class:`Formatter` personnalisé." #: howto/logging-cookbook.rst:653 msgid "" @@ -398,14 +584,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 ses parties intéressantes) peut être stockée dans une variable " +"*threadlocal* (: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 format 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 +617,22 @@ msgid "" "includes a working socket receiver which can be used as a starting point for " "you to adapt in your own applications." msgstr "" +"Bien que la journalisation soit fiable avec les programmes à fils " +"d'exécution multiples, et que la journalisation dans un seul fichier à " +"partir de plusieurs fils d'exécution dans un seul processus *est* prise en " +"charge, la journalisation dans un seul fichier à partir de *plusieurs " +"processus* n'est *pas* prise en charge, car 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 ` 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 +644,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 +667,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 +697,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 +715,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 +750,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 `_ ou `uWSGI `_ " +"(ou similaire), 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 +774,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 +797,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 +823,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 +841,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 +859,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 +879,20 @@ 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'y a aucun intérêt à changer ça (tout en " +"préservant la rétrocompatibilité) puisque, de toutes manières, tous les " +"appels de journalisation dans le code pré-existant utilisent des chaînes au " +"format « % »." #: howto/logging-cookbook.rst:1132 msgid "" @@ -595,6 +902,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 +918,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 +933,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 +944,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 +958,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 doit journaliser le message ``Hello, world!`` quand il " +"est lancé avec Python 3.2 ou ultérieur." #: howto/logging-cookbook.rst:1238 msgid "Customizing ``LogRecord``" From 1c5abf8ef35f3353246b1f8cd62ed49d8c733f80 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Wed, 13 Apr 2022 23:25:09 +0200 Subject: [PATCH 2/6] coquille --- howto/logging-cookbook.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 3d3a57929..175a8b46d 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -6,7 +6,7 @@ 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: 2022-04-13 22:55+0200\n" +"PO-Revision-Date: 2022-04-13 23:00+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -95,7 +95,7 @@ msgstr "" #: howto/logging-cookbook.rst:158 msgid "Multiple handlers and formatters" -msgstr "Plusieurs gestionnaires et formatteurs" +msgstr "Plusieurs gestionnaires et formateurs" #: howto/logging-cookbook.rst:160 msgid "" From e3ca32003f89a55fe03965ad0e059aa173dd22c2 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> Date: Sat, 16 Apr 2022 23:37:17 +0200 Subject: [PATCH 3/6] Apply suggestions from code review Merci Jean. Co-authored-by: Jean Abou-Samra --- howto/logging-cookbook.po | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 175a8b46d..5d15a5a1b 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -50,13 +50,13 @@ msgid "" "logger calls to the child will pass up to the parent. Here is a main " "module::" msgstr "" -"Plusieurs appels à ``logging.getLogger('unLogger')`` renvoient une " +"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 " +"module séparé. Les appels à la journalisation fille passeront alors à la " "journalisation parente. Voici un module principal ::" #: howto/logging-cookbook.rst:55 @@ -116,7 +116,7 @@ msgstr "" "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 ::" +"l'exemple précédent dans une configuration au niveau du module ::" #: howto/logging-cookbook.rst:193 msgid "" @@ -189,7 +189,7 @@ 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 pour fichier, mais vous " +"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 @@ -422,7 +422,7 @@ msgid "" "logging an application, it could be hard to manage if the number of :class:" "`Logger` instances becomes effectively unbounded." msgstr "" -"Parfois, vous souhaitez que la journalisation contienne des informations " +"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 " From 649f2df8b22ed73d9d3c62f1c7680cd1f68dcc94 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sun, 24 Apr 2022 15:58:28 +0200 Subject: [PATCH 4/6] powrap --- howto/logging-cookbook.po | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 5d15a5a1b..49841c81b 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -422,19 +422,19 @@ 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, gérer un nombre potentiellement illimité " -"d'instances de :class:`Logger`, qui dépend du niveau de granularité souhaité " -"pour la journalisation, peut être difficile." +"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, gérer un nombre potentiellement " +"illimité d'instances de :class:`Logger`, qui dépend du niveau de granularité " +"souhaité pour la journalisation, peut être difficile." #: howto/logging-cookbook.rst:575 msgid "Using LoggerAdapters to impart contextual information" From bb8bdfbb0937628e084e795b8cee65ae2e8b24e8 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> Date: Sat, 30 Apr 2022 16:22:23 +0200 Subject: [PATCH 5/6] Apply suggestions from code review Co-authored-by: Jean Abou-Samra --- howto/logging-cookbook.po | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 49841c81b..78593bbc8 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -493,8 +493,8 @@ msgid "" 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 renvoie " -"des versions (potentiellement) modifiées de ceux-ci à utiliser pour la " +"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 " @@ -570,7 +570,7 @@ msgstr "" "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 format appropriée " +"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 @@ -585,12 +585,12 @@ msgid "" "an example script::" msgstr "" "Par exemple, dans une application Web, la requête en cours de traitement (ou " -"du moins ses parties intéressantes) peut être stockée dans une variable " -"*threadlocal* (:class:`threading.local`), puis utilisée dans un ``Filter`` " +"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 format peut être " +"``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 ::" @@ -618,7 +618,7 @@ msgid "" "you to adapt in your own applications." msgstr "" "Bien que la journalisation soit fiable avec les programmes à fils " -"d'exécution multiples, et que la journalisation dans un seul fichier à " +"d'exécution multiples (*thread-safe*), et que la journalisation dans un seul fichier à " "partir de plusieurs fils d'exécution dans un seul processus *est* prise en " "charge, la journalisation dans un seul fichier à partir de *plusieurs " "processus* n'est *pas* prise en charge, car il n'existe aucun moyen standard " @@ -752,7 +752,7 @@ msgid "" msgstr "" "Lors du déploiement d'applications Web qui utilisent `Gunicorn `_ ou `uWSGI `_ " -"(ou similaire), plusieurs processus de travail sont créés pour traiter les " +"(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 " @@ -981,7 +981,7 @@ msgid "" "The above script should log the message ``Hello, world!`` when run with " "Python 3.2 or later." msgstr "" -"Le script ci-dessus doit journaliser le message ``Hello, world!`` quand il " +"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 From 5a71ff21cb30394f6f6ba387caa9a99ed726ebb4 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sat, 30 Apr 2022 16:36:18 +0200 Subject: [PATCH 6/6] prise en compte des remarques de Jean --- howto/logging-cookbook.po | 70 +++++++++++++++++++-------------------- 1 file changed, 34 insertions(+), 36 deletions(-) diff --git a/howto/logging-cookbook.po b/howto/logging-cookbook.po index 78593bbc8..5cb82f6f3 100644 --- a/howto/logging-cookbook.po +++ b/howto/logging-cookbook.po @@ -6,7 +6,7 @@ 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: 2022-04-13 23:00+0200\n" +"PO-Revision-Date: 2022-04-30 16:34+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -432,9 +432,10 @@ msgstr "" "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, gérer un nombre potentiellement " -"illimité d'instances de :class:`Logger`, qui dépend du niveau de granularité " -"souhaité pour la journalisation, peut être difficile." +"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" @@ -493,8 +494,8 @@ msgid "" 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 " +"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 " @@ -585,14 +586,14 @@ msgid "" "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 ::" +"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:" @@ -617,22 +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 "" -"Bien que la journalisation soit fiable avec les programmes à fils " -"d'exécution multiples (*thread-safe*), et que la journalisation dans un seul fichier à " -"partir de plusieurs fils d'exécution dans un seul processus *est* prise en " -"charge, la journalisation dans un seul fichier à partir de *plusieurs " -"processus* n'est *pas* prise en charge, car 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 ` 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." +"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 ` 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 "" @@ -889,10 +888,9 @@ msgstr "" "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'y a aucun intérêt à changer ça (tout en " -"préservant la rétrocompatibilité) puisque, de toutes manières, tous les " -"appels de journalisation dans le code pré-existant utilisent des chaînes au " -"format « % »." +"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 "" @@ -981,8 +979,8 @@ 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." +"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``"