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

# This file is distributed under the same license as the Python package.

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2020-05-05 12:54+0200\n"

"PO-Revision-Date: 2021-08-04 20:41+0200\n"

"Language-Team: python-doc-es\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.8.0\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"

"Language: es\n"

"X-Generator: Poedit 3.0\n"

#: ../Doc/howto/logging-cookbook.rst:5

msgid "Logging Cookbook"

msgstr "Libro de recetas de Logging"

#: ../Doc/howto/logging-cookbook.rst

msgid "Author"

msgstr "Autor"

#: ../Doc/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>"

#: ../Doc/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 ""

"Esta página contiene un número de recetas sobre *logging*, que han sido "

"útiles en el pasado."

#: ../Doc/howto/logging-cookbook.rst:15

msgid "Using logging in multiple modules"

msgstr "Usar logging en múltiples módulos"

#: ../Doc/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 ""

"Múltiples llamadas a ``logging.getLogger('someLogger')`` devuelven una "

"referencia al mismo objeto logger. Esto es cierto no solo dentro del mismo "

"módulo, sino también en todos los módulos siempre que estén ejecutándose en "

"el mismo proceso del intérprete de Python. Es válido para las referencias al "

"mismo objeto. Además, el código de la aplicación puede definir y configurar "

"un logger primario en un módulo y crear (pero no configurar) un logger "

"secundario en un módulo separado, y todas las llamadas al secundario pasarán "

"al principal. A continuación un módulo principal::"

# Esto me confunde un poco. Cuando menciona módulo principal / auxiliar en los ejemplos, ¿se refiere a principal y secundario que está en el cuerpo del texto? ¿no convendría unificar?

#: ../Doc/howto/logging-cookbook.rst:55

msgid "Here is the auxiliary module::"

msgstr "Y aquí un módulo auxiliar::"

#: ../Doc/howto/logging-cookbook.rst:75

msgid "The output looks like this:"

msgstr "El resultado se ve así:"

#: ../Doc/howto/logging-cookbook.rst:101

msgid "Logging from multiple threads"

msgstr "Logging desde múltiples hilos"

#: ../Doc/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 ""

"Realizar *logging* desde múltiples hilos (*threads*) no requiere ningún "

"esfuerzo especial. El siguiente ejemplo muestra el logging desde el hilo "

"principal (inicial) y otro hilo::"

#: ../Doc/howto/logging-cookbook.rst:132

msgid "When run, the script should print something like the following:"

msgstr "Cuando se ejecuta, el script debe imprimir algo como lo siguiente:"

#: ../Doc/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 ""

"Esto muestra la salida de logging intercalada como cabría esperar. Por "

"supuesto, este enfoque funciona para más hilos de lo que se muestran aquí."

#: ../Doc/howto/logging-cookbook.rst:158

msgid "Multiple handlers and formatters"

msgstr "Múltiples gestores y formateadores"

#: ../Doc/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 ""

"Los *loggers* son simples objetos Python. El método :meth:`~Logger."

"addHandler` no tiene una cuota mínima o máxima para la cantidad de gestores "

"(*handlers*) que puede agregar. A veces será beneficioso para una aplicación "

"registrar todos los mensajes de todas las prioridades en un archivo de texto "

"mientras se registran simultáneamente los errores o más en la consola. Para "

"configurar esto, simplemente configure los gestores apropiados. Las llamadas "

"de logging en el código de la aplicación permanecerán sin cambios. Aquí hay "

"una ligera modificación al ejemplo de configuración simple anterior basado "

"en módulo::"

#: ../Doc/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 ""

"Tenga en cuenta que el código de la 'aplicación' no se preocupa por los "

"gestores múltiples. Todo lo que cambió fue la adición y configuración de un "

"nuevo gestor llamado *fh*."

#: ../Doc/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 capacidad de crear nuevos gestores con filtros de mayor o menor prioridad "

"puede ser muy útil al escribir y probar una aplicación. En lugar de usar "

"muchas declaraciones ``print`` para la depuración, use ``logger.debug``: a "

"diferencia de las declaraciones de impresión, que tendrá que eliminar o "

"comentar más tarde, las declaraciones de *logger.debug* pueden permanecer "

"intactas en el código fuente y permanecen inactivas hasta que las necesite "

"nuevamente. En ese momento, el único cambio que debe realizar es modificar "

"el nivel de prioridad del *logger* y/o gestor para depurar."

#: ../Doc/howto/logging-cookbook.rst:207

msgid "Logging to multiple destinations"

msgstr "Logging en múltiples destinos"

#: ../Doc/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 ""

"Supongamos que desea que la consola y un archivo tengan diferentes formatos "

"de mensaje y salida de log para diferentes situaciones. Por ejemplo, desea "

"registrar mensajes con un nivel DEBUG y superiores en un archivo y enviar "

"mensajes con nivel INFO y superior a la consola. Además, suponga que desea "

"grabar una marca de tiempo en el archivo y no imprimirlo en la consola. "

"Puede lograr este comportamiento haciendo lo siguiente::"

#: ../Doc/howto/logging-cookbook.rst:247

msgid "When you run this, on the console you will see"

msgstr "Cuando ejecute esto, en la consola verá"

#: ../Doc/howto/logging-cookbook.rst:256

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

msgstr "y en el archivo verá algo como"

#: ../Doc/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 ""

"Como se puede ver, el mensaje DEBUG sólo se muestra en el archivo. Los otros "

"mensajes se envían a los dos destinos."

#: ../Doc/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 ""

"Este ejemplo usa gestores de consola y archivos, pero puede usar cualquier "

"número y combinación de los gestores que elija."

#: ../Doc/howto/logging-cookbook.rst:274

msgid "Configuration server example"

msgstr "Ejemplo de servidor de configuración"

#: ../Doc/howto/logging-cookbook.rst:276

msgid "Here is an example of a module using the logging configuration server::"

msgstr ""

"Aquí hay un ejemplo de un módulo que usa el servidor de configuración "

"logging::"

#: ../Doc/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 ""

"Y aquí hay un script que toma un nombre de archivo y envía ese archivo al "

"servidor, precedido adecuadamente con la longitud codificada en binario, "

"como la nueva configuración de logging::"

#: ../Doc/howto/logging-cookbook.rst:330

msgid "Dealing with handlers that block"

msgstr "Tratar con gestores que bloquean"

#: ../Doc/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 ""

"A veces tiene que hacer que sus gestores de logging hagan su trabajo sin "

"bloquear el hilo desde el que está iniciando sesión. Esto es común en las "

"aplicaciones web, aunque, por supuesto, también ocurre en otros escenarios."

# -"under the hood": de bajo nivel? más técnicas?

#: ../Doc/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 responsable habitual que ejemplifica un comportamiento lento es la :class:"

"`SMTPHandler`: el envío de correos electrónicos puede llevar mucho tiempo, "

"por varias razones fuera del control del desarrollador (por ejemplo, una "

"infraestructura de red o correo de bajo rendimiento). Pero casi cualquier "

"controlador basado en red puede bloquear: incluso una operación :class:"

"`SocketHandler` puede estar haciendo a bajo nivel una consulta DNS que es "

"demasiado lenta (y esta consulta puede estar en el código de la biblioteca "

"de socket, debajo de la capa de Python, y fuera de su control)."

#: ../Doc/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 ""

"Una solución es utilizar un enfoque de dos partes. Para la primera parte, "

"adjunte solo una :class:`QueueHandler` a los loggers que se acceden desde "

"subprocesos críticos de rendimiento. Simplemente escriben en su cola, que "

"puede dimensionarse a una capacidad lo suficientemente grande o "

"inicializarse sin límite superior a su tamaño. La escritura en la cola "

"generalmente se aceptará rápidamente, aunque es probable que deba atrapar la "

"excepción :exc:`queue.Full` como precaución en su código. Si usted es un "

"desarrollador de bibliotecas que tiene subprocesos críticos de rendimiento "

"en su código, asegúrese de documentar esto (junto con una sugerencia de "

"adjuntar solo ``QueueHandlers`` a sus loggers) para el beneficio de otros "

"desarrolladores que usarán su código."

#: ../Doc/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 segunda parte de la solución es :class:`QueueListener`, que fue designado "

"como la contraparte de :class:`QueueHandler`. Un :class:`QueueListener` es "

"muy simple: ha pasado una cola y algunos gestores, y activa un hilo interno "

"que escucha su cola para *LogRecords* enviados desde ``QueueHandlers`` (o "

"cualquier otra fuente de ``LogRecords``, para el caso). Los ``LogRecords`` "

"se eliminan de la cola y se pasan a los gestores para su procesamiento."

#: ../Doc/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 ""

"La ventaja de tener una clase separada :class:`QueueListener` es que puede "

"usar la misma instancia para dar servicio a múltiples ``QueueHandlers``. "

"Esto es más amigable con los recursos que, por ejemplo, tener versiones "

"enhebradas de las clases de gestores existentes, que consumirían un hilo por "

"gestor sin ningún beneficio particular."

#: ../Doc/howto/logging-cookbook.rst:370

msgid "An example of using these two classes follows (imports omitted)::"

msgstr ""

"Un ejemplo del uso de estas dos clases a continuación (se omiten *imports*)::"

#: ../Doc/howto/logging-cookbook.rst:388

msgid "which, when run, will produce:"

msgstr "que, cuando se ejecuta, producirá:"

#: ../Doc/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 ""

"Antes de Python 3.5, :class:`QueueListener` siempre pasaba cada mensaje "

"recibido de la cola a cada controlador con el que se inicializaba. (Esto se "

"debió a que se asumió que el filtrado de nivel se realizó en el otro lado, "

"donde se llena la cola). A partir de 3.5, este comportamiento se puede "

"cambiar pasando un argumento de palabra clave ``respect_handler_level=True`` "

"al constructor del oyente . Cuando se hace esto, el oyente compara el nivel "

"de cada mensaje con el nivel del controlador y solo pasa un mensaje a un "

"controlador si es apropiado hacerlo."

#: ../Doc/howto/logging-cookbook.rst:407

msgid "Sending and receiving logging events across a network"

msgstr "Enviar y recibir eventos logging a través de una red"

#: ../Doc/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 ""

"Supongamos que desea enviar eventos de registro a través de una red y "

"manejarlos en el extremo receptor. Una forma sencilla de hacer esto es "

"adjuntar una instancia de :class:`SocketHandler` al registrador raíz en el "

"extremo de envío::"

#: ../Doc/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 ""

"En el extremo receptor, puede configurar un receptor usando el módulo :mod:"

"`socketserver`. Aquí hay un ejemplo básico de trabajo:"

#: ../Doc/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 ""

"Primero ejecuta el servidor, y luego el cliente. Del lado del cliente, nada "

"se imprime en la consola; del lado del servidor, se debería ver algo como "

"esto:"

#: ../Doc/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 ""

"Tenga en cuenta que existen algunos problemas de seguridad con pickle en "

"algunos escenarios. Si estos le afectan, puede usar un esquema de "

"serialización alternativo anulando el método :meth:`~ handlers.SocketHandler."

"makePickle` e implementando su alternativa allí, así como adaptar el script "

"anterior para usar su serialización alternativa."

#: ../Doc/howto/logging-cookbook.rst:547

msgid "Adding contextual information to your logging output"

msgstr "Agregar información contextual a su salida de logging"

# no estoy seguro de la parte "se liberan de memoria via recolector de basura". En la wikipedia en español lo llaman así. "se liberan de memoria" es una agregado mío.

#: ../Doc/howto/logging-cookbook.rst:549

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

"A veces, desea que la salida de logging contenga información contextual "

"además de los parámetros pasados a la llamada del logging. Por ejemplo, en "

"una aplicación en red, puede ser conveniente registrar información "

"específica del cliente en el logging (por ejemplo, el nombre de usuario del "

"cliente remoto o la dirección IP). Aunque puede usar el parámetro *extra* "

"para lograr esto, no siempre es conveniente pasar la información de esta "

"manera. Si bien puede resultar tentador crear instancias :class:`Logger` por "

"conexión, esta no es una buena idea porque estas instancias no se liberan de "

"memoria vía el recolector de basura (*garbage collector*). Si bien esto no "

"es un problema en la práctica, cuando el número de instancias de :class:"

"`Logger` depende del nivel de granularidad que desea usar para hacer el "

"logging de una aplicación, podría ser difícil de administrar si el número de "

"instancias :class:`Logger` se vuelven efectivamente ilimitadas."

#: ../Doc/howto/logging-cookbook.rst:564

msgid "Using LoggerAdapters to impart contextual information"

msgstr "Uso de LoggerAdapters para impartir información contextual"

# "signatures" por "características"?

#: ../Doc/howto/logging-cookbook.rst:566

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

"Una manera fácil de pasar información contextual para que se genere junto "

"con la información de eventos logging es usar la clase :class:"

"`LoggerAdapter`. Esta clase está diseñada para parecerse a :class:`Logger`, "

"de modo que pueda llamar :meth:`debug`, :meth:`info`, :meth:`warning`, :meth:"

"`error`, :meth:`excepción`, :meth:`critical` y :meth:`log`. Estos métodos "

"tienen las mismas signaturas que sus contrapartes en :class:`Logger`, por lo "

"que puede usar los dos tipos de instancias indistintamente."

#: ../Doc/howto/logging-cookbook.rst:574

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

"Cuando creas una instancia de :class:`LoggerAdapter`, le pasas una instancia "

"de :class:`Logger` y un objeto similar a un dict que contiene tu información "

"contextual. Cuando llamas a uno de los métodos de registro en una instancia "

"de :class:`LoggerAdapter`, delega la llamada a la instancia subyacente de :"

"class:`Logger` pasada a su constructor, y se arregla para pasar la "

"información contextual en la llamada delegada . Aquí hay un fragmento del "

"código de :class:`LoggerAdapter`::"

#: ../Doc/howto/logging-cookbook.rst:590

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

"El método :meth:`~LoggerAdapter.process` de :class:`LoggerAdapter` es donde "

"la información contextual se agrega a la salida del logging. Se pasa el "

"mensaje y los argumentos de palabra clave de la llamada logging, y retorna "

"versiones (potencialmente) modificadas de estos para usar en la llamada al "

"logging subyacente. La implementación predeterminada de este método deja el "

"mensaje solo, pero inserta una clave 'extra' en el argumento de palabra "

"clave cuyo valor es el objeto tipo dict pasado al constructor. Por supuesto, "

"si ha pasado un argumento de palabra clave 'extra' en la llamada al "

"adaptador, se sobrescribirá silenciosamente."

#: ../Doc/howto/logging-cookbook.rst:599

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

"La ventaja de usar 'extra' es que los valores en el objeto dict se combinan "

"en la instancia :class:`LogRecord` __dict__, lo que le permite usar cadenas "

"personalizadas con sus instancias :class:`Formatter` que conocen las claves "

"del objeto dict. Si necesita un método diferente, por ejemplo, si desea "

"anteponer o agregar la información contextual a la cadena del mensaje, solo "

"necesita la subclase :class:`LoggerAdapter` y anular :meth:`~LoggerAdapter."

"process` para hacer lo que necesita. Aquí hay un ejemplo simple:"

#: ../Doc/howto/logging-cookbook.rst:615

msgid "which you can use like this::"

msgstr "que puede usar así::"

#: ../Doc/howto/logging-cookbook.rst:620

msgid ""

"Then any events that you log to the adapter will have the value of "

"``some_conn_id`` prepended to the log messages."

msgstr ""

"Luego, cualquier evento que registre en el adaptador tendrá el valor de "

"``some_conn_id`` antepuesto a los mensajes de logging."

#: ../Doc/howto/logging-cookbook.rst:624

msgid "Using objects other than dicts to pass contextual information"

msgstr ""

"Usar objetos distintos a los diccionarios para transmitir información "

"contextual"

#: ../Doc/howto/logging-cookbook.rst:626

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

"No es necesario pasar un diccionario real a la :class:`LoggerAdapter` - "

"puedes pasar una instancia de una clase que implemente ``__getitem__`` y "

"``__iter__`` de modo que parezca un diccionario para el logging. Esto es "

"útil si quieres generar valores dinámicamente (mientras que los valores en "

"un diccionario son constantes)."

#: ../Doc/howto/logging-cookbook.rst:635

msgid "Using Filters to impart contextual information"

msgstr "Usar filtros para impartir información contextual"

#: ../Doc/howto/logging-cookbook.rst:637

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

"También puedes agregar información contextual a la salida del log utilizando "

"un :class:`Filter` definido por el usuario. Las instancias de ``Filter`` "

"pueden modificar los ``LogRecords`` que se les pasan, incluido el agregado "

"de atributos adicionales que luego se pueden generar utilizando cadena de "

"caracteres con el formato adecuado, o si es necesario, un :class:`Formatter` "

"personalizado."

#: ../Doc/howto/logging-cookbook.rst:642

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

"Por ejemplo, en una aplicación web, la solicitud que se está procesando (o "

"al menos, las partes interesantes de la misma) se pueden almacenar en una "

"variable *threadlocal* (:class:`threading.local`) y luego se puede acceder a "

"ella desde ``Filter`` para agregar información de la solicitud, - digamos, "

"la dirección IP remota y el nombre de usuario-, al ``LogRecord``, usando los "

"nombres de atributo 'ip' y 'user' como en el ejemplo anterior de "

"``LoggerAdapter``. En ese caso, se puede usar el mismo formato de cadena de "

"caracteres para obtener un resultado similar al que se muestra arriba. Aquí "

"hay un script de ejemplo::"

#: ../Doc/howto/logging-cookbook.rst:688

msgid "which, when run, produces something like:"

msgstr "que cuando se ejecuta, produce algo como:"

#: ../Doc/howto/logging-cookbook.rst:709

msgid "Logging to a single file from multiple processes"

msgstr "Logging a un sólo archivo desde múltiples procesos"

# Traté de refrasear las primeras oraciones para que no sea super repetitivo.

# No tengo claro cómo es todo el tema de socket y si está bien traducido "socket server", "working socket".

#: ../Doc/howto/logging-cookbook.rst:711

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

"Aunque logging es seguro para hilos, y el logging a un solo archivo desde "

"múltiples hilos en un solo proceso *es* compatible, el logging en un solo "

"archivo desde *múltiples procesos* *no* es compatible, porque no existe una "

"forma estándar de serializar el acceso a un solo archivo en múltiples "

"procesos en Python. Si necesita hacer esto último, una forma de abordarlo es "

"hacer que todos los procesos se registren en una :class:`~handlers."

"SocketHandler`, y tener un proceso separado que implemente un servidor de "

"socket que lee del socket y los loggings para archivar. (Si lo prefiere, "

"puede dedicar un hilo en uno de los procesos existentes para realizar esta "

"función.) :ref:`Esta sección <network-logging>` documenta este enfoque con "

"más detalle e incluye un receptor socket que funciona que se puede utilizar "

"como punto de partida para que se adapte a sus propias aplicaciones."

#: ../Doc/howto/logging-cookbook.rst:724

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

"También puedes escribir tu propio gestor que use la clase :class:"

"`~multiprocessing.Lock` del módulo :mod:`multiprocessing` para serializar el "

"acceso al archivo desde tus procesos. La existente :class:`FileHandler` y "

"las subclases no hacen uso de :mod:`multiprocessing` en la actualidad, "

"aunque pueden hacerlo en el futuro. Tenga en cuenta que, en la actualidad, "

"el módulo :mod:`multiprocessing` no proporciona la funcionalidad de bloqueo "

"de trabajo en todas las plataformas (ver https://bugs.python.org/issue3770)."

#: ../Doc/howto/logging-cookbook.rst:734

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

"Alternativamente, puede usar una ``Queue`` y :class:`QueueHandler` para "

"enviar todos los logging a uno de los procesos en su aplicación multi-"

"proceso. El siguiente script de ejemplo demuestra cómo puede hacer esto; en "

"el ejemplo, un proceso de escucha independiente escucha los eventos enviados "

"por otros procesos y los registra de acuerdo con su propia configuración de "

"logging. Aunque el ejemplo solo demuestra una forma de hacerlo (por ejemplo, "

"es posible que desee utilizar un hilo de escucha en lugar de un proceso de "

"escucha separado; la implementación sería análoga), permite configuraciones "

"de logging completamente diferentes para el oyente y los otros procesos en "

"su aplicación. Y se puede utilizar como base para el código que cumpla con "

"sus propios requisitos específicos::"

#: ../Doc/howto/logging-cookbook.rst:850

msgid ""

"A variant of the above script keeps the logging in the main process, in a "

"separate thread::"

msgstr ""

"Una variante del script anterior mantiene el logging en el proceso "

"principal, en un hilo separado::"

#: ../Doc/howto/logging-cookbook.rst:945

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

"Esta variante muestra cómo puede, por ejemplo, aplicar la configuración para "

"logging particulares: el registrador ``foo`` tiene un gestor especial que "

"almacena todos los eventos en el subsistema ``foo`` en un archivo ``mplog-"

"foo.log``. Esto será utilizado por la maquinaria de logging en el proceso "

"principal (aunque los eventos logging se generen en los procesos de trabajo) "

"para dirigir los mensajes a los destinos apropiados."

#: ../Doc/howto/logging-cookbook.rst:952

msgid "Using concurrent.futures.ProcessPoolExecutor"

msgstr "Usando concurrent.futures.ProcessPoolExecutor"

#: ../Doc/howto/logging-cookbook.rst:954

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 desea utilizar :class:`concurrent.futures.ProcessPoolExecutor` para "

"iniciar sus procesos de trabajo, debe crear la cola de manera ligeramente "

"diferente. En vez de"

#: ../Doc/howto/logging-cookbook.rst:962

msgid "you should use"

msgstr "debería usar"

#: ../Doc/howto/logging-cookbook.rst:968

msgid "and you can then replace the worker creation from this::"

msgstr "y luego puede reemplazar la creación del trabajador de esto::"

#: ../Doc/howto/logging-cookbook.rst:979

msgid "to this (remembering to first import :mod:`concurrent.futures`)::"

msgstr "a esto (recuerda el primer *import* :mod:`concurrent.futures`)::"

#: ../Doc/howto/logging-cookbook.rst:987

msgid "Using file rotation"

msgstr "Usando rotación de archivos"

#: ../Doc/howto/logging-cookbook.rst:992

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

"A veces, se desea dejar que un archivo de log crezca hasta cierto tamaño y "

"luego abra un nuevo archivo e inicie sesión en él. Es posible que desee "

"conservar una cierta cantidad de estos archivos, y cuando se hayan creado "

"tantos archivos, rote los archivos para que la cantidad de archivos y el "

"tamaño de los archivos permanezcan limitados. Para este patrón de uso, el "

"paquete logging proporciona :class:`~handlers.RotatingFileHandler`::"

#: ../Doc/howto/logging-cookbook.rst:1024

msgid ""

"The result should be 6 separate files, each with part of the log history for "

"the application:"

msgstr ""

"El resultado debe ser 6 archivos separados, cada uno con parte del historial "

"de log de la aplicación:"

#: ../Doc/howto/logging-cookbook.rst:1036

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

"El archivo más actual siempre es :file:`logging_rotatingfile_example.out`, y "

"cada vez que alcanza el límite de tamaño, se le cambia el nombre con el "

"sufijo``.1``. Se cambia el nombre de cada uno de los archivos de respaldo "

"existentes para incrementar el sufijo (``.1`` se convierte en ``.2``, etc.) "

"y se borra el archivo ``.6``."

#: ../Doc/howto/logging-cookbook.rst:1041

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

"Obviamente, este ejemplo establece la longitud del log demasiado pequeña "

"como un ejemplo extremo. Se querrá establecer *maxBytes* en un valor "

"apropiado."

#: ../Doc/howto/logging-cookbook.rst:1047

msgid "Use of alternative formatting styles"

msgstr "Uso de estilos de formato alternativos"

#: ../Doc/howto/logging-cookbook.rst:1049

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

"Cuando se agregó logging a la biblioteca estándar de Python, la única forma "

"de formatear mensajes con contenido variable era usar el método de formateo "

"'%'. Desde entonces, Python ha ganado dos nuevos enfoques de formato: :class:"

"`string.Template` (agregado en Python 2.4) y :meth:`str.format` (agregado en "

"Python 2.6)."

#: ../Doc/howto/logging-cookbook.rst:1055

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

"Logging (a partir de la versión 3.2) proporciona un soporte mejorado para "

"estos dos estilos de formato adicionales. La clase :class:`Formatter` ha "

"sido mejorada para tomar un parámetro de palabra clave adicional llamado "

"``style``. El valor predeterminado es ``'%'``, pero otros valores posibles "

"son ``'{'`` y ``'$'``, que corresponden a los otros dos estilos de formato. "

"La compatibilidad con versiones anteriores se mantiene de forma "

"predeterminada (como era de esperar), pero al especificar explícitamente un "

"parámetro de estilo, tiene la capacidad de especificar cadenas de formato "

"que funcionan con :meth:`str.format` o :class:`string.Template`. Aquí hay "

"una sesión de consola de ejemplo para mostrar las posibilidades:"

#: ../Doc/howto/logging-cookbook.rst:1089

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

"Tenga en cuenta que el formato de logging para la salida final a los logs es "

"completamente independiente de cómo se construye un mensaje de logging "

"individual. Para eso todavía puede usar el formateo \"%\", como se muestra "

"aquí:"

# No entiendo este bloque en inglés ni en español :P

#: ../Doc/howto/logging-cookbook.rst:1097

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

"Las llamadas de Logging (``logger.debug()``, ``logger.info()``, etc.) solo "

"toman parámetros posicionales para el mensaje de logging real en sí, los "

"parámetros de palabras clave se usan solo para determinar opciones sobre "

"cómo gestionar la llamada propiamente a Logging (por ejemplo, el parámetro "

"de palabra clave ``exc_info`` para indicar que la información de rastreo "

"debe registrarse, o el parámetro de palabra clave ``extra`` para indicar "

"información contextual adicional que se agregará al log). Por lo tanto, no "

"puede realizar llamadas de logging directamente usando la sintaxis :meth:"

"`str.format` o :class:`string.Template`, porque internamente el paquete de "

"logging usa formato % para fusionar la cadena de formato y los argumentos de "

"las variables. No habría ningún cambio en esto mientras se conserva la "

"compatibilidad con versiones anteriores, ya que todas las llamadas de "

"logging que están en el código existente usarán cadenas de formato %."

#: ../Doc/howto/logging-cookbook.rst:1110

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

"Sin embargo, existe una forma en la que puede usar el formato {} - y $ - "

"para construir sus mensajes de log individuales. Recuerde que para un "

"mensaje puede usar un objeto arbitrario como una cadena de caracteres de "

"formato de mensaje, y que el paquete logging llamará a ``str()`` en ese "

"objeto para obtener la cadena de caracteres de formato real. Considere las "

"siguientes dos clases::"

#: ../Doc/howto/logging-cookbook.rst:1134

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

"Cualquiera de estos puede usarse en lugar de una cadena de formato, para "

"permitir que se use el formato {} - o $ - para construir la parte del "

"\"mensaje\" real que aparece en la salida del log en lugar de \"%(message)s"

"\" o \"{message}\" o \"$message\". Es un poco difícil de manejar usar los "

"nombres de las clases siempre que quieras registrar algo, pero es bastante "

"aceptable si usas un alias como __ (doble subrayado --- no confundir con _, "

"el subrayado simple usado como sinónimo/alias para :func:`gettext.gettext` o "

"sus hermanos)."

#: ../Doc/howto/logging-cookbook.rst:1142

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

"Las clases anteriores no están incluidas en Python, aunque son bastante "

"fáciles de copiar y pegar en su propio código. Se pueden usar de la "

"siguiente manera (asumiendo que están declaradas en un módulo llamado "

"``wherever``):"

#: ../Doc/howto/logging-cookbook.rst:1164

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

"Si bien los ejemplos anteriores usan ``print()`` para mostrar cómo funciona "

"el formateo, por supuesto usaría ``logger.debug()`` o similar para realmente "

"registrar usando este enfoque."

#: ../Doc/howto/logging-cookbook.rst:1168

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

"Una cosa a tener en cuenta es que no paga una penalización de rendimiento "

"significativa con este enfoque: el formateo real no ocurre cuando realiza la "

"llamada a logging, sino cuando (y si) el mensaje registrado está a punto de "

"ser enviado a un log por un gestor. Entonces, lo único un poco inusual que "

"podría confundirte es que los paréntesis rodean la cadena de formato y los "

"argumentos, no solo la cadena de formato. Eso es porque la notación __ es "

"solo azúcar sintáctico para una llamada de constructor a una de las clases "

"XXXMessage."

#: ../Doc/howto/logging-cookbook.rst:1176

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 lo prefiere, puede usar :class:`LoggerAdapter` para lograr un efecto "

"similar al anterior, como en el siguiente ejemplo::"

#: ../Doc/howto/logging-cookbook.rst:1207

msgid ""

"The above script should log the message ``Hello, world!`` when run with "

"Python 3.2 or later."

msgstr ""

"El script anterior debería registrar el mensaje ``Hello, world!`` Cuando se "

"ejecuta con Python 3.2 o posterior."

#: ../Doc/howto/logging-cookbook.rst:1216

msgid "Customizing ``LogRecord``"

msgstr "Personalización de ``LogRecord``"

#: ../Doc/howto/logging-cookbook.rst:1218

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

"Cada evento logging está representado por una instancia :class:`LogRecord`. "

"Cuando se registra un evento y no se filtra por el nivel de un registrador, "

"se crea :class:`LogRecord`, se llena con información sobre el evento y luego "

"se pasa a los gestores de ese registrador (y sus antepasados, hasta (e "

"incluyéndolo) el registrador donde se deshabilita una mayor propagación en "

"la jerarquía). Antes de Python 3.2, solo había dos lugares donde se "

"realizaba esta creación:"

#: ../Doc/howto/logging-cookbook.rst:1225

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`, que se llama en el proceso normal de logging de "

"un evento. Esto invoca :class:`LogRecord` directamente para crear una "

"instancia."

#: ../Doc/howto/logging-cookbook.rst:1228

msgid ""

":func:`makeLogRecord`, which is called with a dictionary containing "

"attributes to be added to the LogRecord. This is typically invoked when a "

"suitable dictionary has been received over the network (e.g. in pickle form "

"via a :class:`~handlers.SocketHandler`, or in JSON form via an :class:"

"`~handlers.HTTPHandler`)."

msgstr ""

":func:`makeLogRecord`, que se llama con un diccionario que contiene "

"atributos que se agregarán al *LogRecord*. Esto se suele invocar cuando se "

"ha recibido un diccionario adecuado a través de la red (por ejemplo, en "

"forma de *pickle* a través de :class:`~handlers.SocketHandler`, o en formato "

"JSON a través de :class:`~handlers.HTTPHandler`)."

#: ../Doc/howto/logging-cookbook.rst:1234

msgid ""

"This has usually meant that if you need to do anything special with a :class:"

"`LogRecord`, you've had to do one of the following."

msgstr ""

"Por lo general, esto significa que si necesita hacer algo especial con :"

"class:`LogRecord`, debe hacer una de las siguientes cosas."

#: ../Doc/howto/logging-cookbook.rst:1237

msgid ""

"Create your own :class:`Logger` subclass, which overrides :meth:`Logger."

"makeRecord`, and set it using :func:`~logging.setLoggerClass` before any "

"loggers that you care about are instantiated."

msgstr ""

"Cree su propia subclase :class:`Logger`, que anula :meth:`Logger."

"makeRecord`, y configúrelo usando :func:`~logging.setLoggerClass` antes de "

"que se creen instancias de los registradores que le interesan."

#: ../Doc/howto/logging-cookbook.rst:1240

msgid ""

"Add a :class:`Filter` to a logger or handler, which does the necessary "

"special manipulation you need when its :meth:`~Filter.filter` method is "

"called."

msgstr ""

"Agrega un :class:`Filter` a un registrador o gestor, que realiza la "

"manipulación especial necesaria que necesita cuando se llama a su método :"

"meth:`~Filter.filter`."

#: ../Doc/howto/logging-cookbook.rst:1244