logging-cookbook.po

# 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: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2022-10-27 15:51-0300\n"
"Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\n"
"Language-Team: python-doc-es\n"
"Language: es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.10.3\n"
"X-Generator: Poedit 3.0.1\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. For links to tutorial and reference information, "
"please see :ref:`cookbook-ref-links`."
msgstr ""
"Esta página contiene un número de recetas sobre *logging*, que han sido "
"útiles en el pasado. Para obtener enlaces al tutorial e información de "
"referencia, consulte :ref:`cookbook-ref-links`."

#: ../Doc/howto/logging-cookbook.rst:16
msgid "Using logging in multiple modules"
msgstr "Usar logging en múltiples módulos"

#: ../Doc/howto/logging-cookbook.rst:18
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')`` retornan 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:56
msgid "Here is the auxiliary module::"
msgstr "Y aquí un módulo auxiliar::"

#: ../Doc/howto/logging-cookbook.rst:76
msgid "The output looks like this:"
msgstr "El resultado se ve así:"

#: ../Doc/howto/logging-cookbook.rst:102
msgid "Logging from multiple threads"
msgstr "Logging desde múltiples hilos"

#: ../Doc/howto/logging-cookbook.rst:104
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:133
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:155
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:159
msgid "Multiple handlers and formatters"
msgstr "Múltiples gestores y formateadores"

#: ../Doc/howto/logging-cookbook.rst:161
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:194
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:197
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:208
msgid "Logging to multiple destinations"
msgstr "Logging en múltiples destinos"

#: ../Doc/howto/logging-cookbook.rst:210
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:248
msgid "When you run this, on the console you will see"
msgstr "Cuando ejecute esto, en la consola verá"

#: ../Doc/howto/logging-cookbook.rst:257
msgid "and in the file you will see something like"
msgstr "y en el archivo verá algo como"

#: ../Doc/howto/logging-cookbook.rst:267
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:270
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:273
msgid ""
"Note that the above choice of log filename ``/tmp/myapp.log`` implies use of "
"a standard location for temporary files on POSIX systems. On Windows, you "
"may need to choose a different directory name for the log - just ensure that "
"the directory exists and that you have the permissions to create and update "
"files in it."
msgstr ""
"Tenga en cuenta que la elección anterior del nombre del archivo de registro "
"``/tmp/myapp.log`` implica el uso de una ubicación estándar para los "
"archivos temporales en los sistemas POSIX. En Windows, es posible que tenga "
"que elegir un nombre de directorio diferente para el registro - sólo "
"asegúrese de que el directorio existe y que tiene los permisos para crear y "
"actualizar archivos en él."

#: ../Doc/howto/logging-cookbook.rst:282
msgid "Custom handling of levels"
msgstr "Gestión personalizada de niveles"

#: ../Doc/howto/logging-cookbook.rst:284
msgid ""
"Sometimes, you might want to do something slightly different from the "
"standard handling of levels in handlers, where all levels above a threshold "
"get processed by a handler. To do this, you need to use filters. Let's look "
"at a scenario where you want to arrange things as follows:"
msgstr ""
"A veces, es posible que desee hacer algo ligeramente diferente del manejo "
"estándar de niveles, donde todos los niveles por encima de un umbral son "
"procesados por un gestor. Para ello, es necesario utilizar filtros. Veamos "
"un escenario en el que se desea organizar las cosas de la siguiente manera:"

#: ../Doc/howto/logging-cookbook.rst:289
msgid "Send messages of severity ``INFO`` and ``WARNING`` to ``sys.stdout``"
msgstr "Enviar mensajes de gravedad ``INFO`` y ``WARNING`` a ``sys.stdout``"

#: ../Doc/howto/logging-cookbook.rst:290
msgid "Send messages of severity ``ERROR`` and above to ``sys.stderr``"
msgstr "Enviar mensajes de gravedad ``ERROR`` y superiores a ``sys.stderr``"

#: ../Doc/howto/logging-cookbook.rst:291
msgid "Send messages of severity ``DEBUG`` and above to file ``app.log``"
msgstr ""
"Envía los mensajes de gravedad ``DEBUG`` y superiores al archivo ``app.log``"

#: ../Doc/howto/logging-cookbook.rst:293
msgid "Suppose you configure logging with the following JSON:"
msgstr "Supongamos que se configura el registro con el siguiente JSON:"

#: ../Doc/howto/logging-cookbook.rst:335
msgid ""
"This configuration does *almost* what we want, except that ``sys.stdout`` "
"would show messages of severity ``ERROR`` and above as well as ``INFO`` and "
"``WARNING`` messages. To prevent this, we can set up a filter which excludes "
"those messages and add it to the relevant handler. This can be configured by "
"adding a ``filters`` section parallel to ``formatters`` and ``handlers``:"
msgstr ""
"Esta configuración hace *casi* lo que queremos, excepto que ``sys.stdout`` "
"mostraría mensajes de gravedad ``ERROR`` y superiores, así como mensajes "
"``INFO`` y ``WARNING``. Para evitarlo, podemos configurar un filtro que "
"excluya esos mensajes y añadirlo al gestor correspondiente. Esto se puede "
"configurar añadiendo una sección ``filters`` paralela a ``formatters`` y "
"``handlers``:"

#: ../Doc/howto/logging-cookbook.rst:350
msgid "and changing the section on the ``stdout`` handler to add it:"
msgstr "y cambiando la sección del gestor ``stdout`` para añadirlo:"

#: ../Doc/howto/logging-cookbook.rst:362
msgid ""
"A filter is just a function, so we can define the ``filter_maker`` (a "
"factory function) as follows:"
msgstr ""
"Un filtro no es más que una función, por lo que podemos definir el "
"``filter_maker`` (una función de fábrica) como sigue:"

#: ../Doc/howto/logging-cookbook.rst:375
msgid ""
"This converts the string argument passed in to a numeric level, and returns "
"a function which only returns ``True`` if the level of the passed in record "
"is at or below the specified level. Note that in this example I have defined "
"the ``filter_maker`` in a test script ``main.py`` that I run from the "
"command line, so its module will be ``__main__`` - hence the ``__main__."
"filter_maker`` in the filter configuration. You will need to change that if "
"you define it in a different module."
msgstr ""
"Esto convierte el argumento de la cadena de caracteres pasada en un nivel "
"numérico, y retorna una función que sólo retorna ``True`` si el nivel del "
"registro pasado está en o por debajo del nivel especificado. Ten en cuenta "
"que en este ejemplo se ha definido el ``filter_maker`` en un script de "
"prueba ``main.py`` que se ejecuta desde la línea de comandos, por lo que su "
"módulo será ``__main__`` - de ahí el ``__main__.filter_maker`` en la "
"configuración del filtro. Tendrás que cambiar eso si lo defines en un módulo "
"diferente."

#: ../Doc/howto/logging-cookbook.rst:383
msgid "With the filter added, we can run ``main.py``, which in full is:"
msgstr ""
"Con el filtro añadido, podemos ejecutar ``main.py``, que en su totalidad es:"

#: ../Doc/howto/logging-cookbook.rst:453
msgid "And after running it like this:"
msgstr "Y después de ejecutarlo de esta manera:"

#: ../Doc/howto/logging-cookbook.rst:459
msgid "We can see the results are as expected:"
msgstr "Podemos ver que los resultados son los esperados:"

#: ../Doc/howto/logging-cookbook.rst:485
msgid "Configuration server example"
msgstr "Ejemplo de servidor de configuración"

#: ../Doc/howto/logging-cookbook.rst:487
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:518
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:543
msgid "Dealing with handlers that block"
msgstr "Tratar con gestores que bloquean"

#: ../Doc/howto/logging-cookbook.rst:547
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 registro 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:551
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:559
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:570
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:578
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:583
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:601
msgid "which, when run, will produce:"
msgstr "que, cuando se ejecuta, producirá:"

#: ../Doc/howto/logging-cookbook.rst:607
msgid ""
"Although the earlier discussion wasn't specifically talking about async "
"code, but rather about slow logging handlers, it should be noted that when "
"logging from async code, network and even file handlers could lead to "
"problems (blocking the event loop) because some logging is done from :mod:"
"`asyncio` internals. It might be best, if any async code is used in an "
"application, to use the above approach for logging, so that any blocking "
"code runs only in the ``QueueListener`` thread."
msgstr ""
"Aunque la discusión anterior no se refería específicamente al código "
"asíncrono, sino más bien a los gestores de logging lentos, hay que tener en "
"cuenta que cuando se realiza logging desde código asíncrono, los gestores de "
"red e incluso de archivos podrían dar problemas (bloqueo del bucle de "
"eventos) porque parte del logging se realiza desde los internos de :mod:"
"`asyncio`. Podría ser mejor, si se utiliza cualquier código asíncrono en una "
"aplicación, utilizar el enfoque anterior para el logging, de modo que "
"cualquier código de bloqueo se ejecute sólo en el hilo ``QueueListener``."

#: ../Doc/howto/logging-cookbook.rst:615
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:628
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:630
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 "
"gestionarlos 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:658
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:746
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:758
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:766
msgid "Running a logging socket listener in production"
msgstr "Ejecutando un logging de socket oyente en producción"

#: ../Doc/howto/logging-cookbook.rst:768
msgid ""
"To run a logging listener in production, you may need to use a process-"
"management tool such as `Supervisor <http://supervisord.org/>`_. `Here "
"<https://gist.github.com/vsajip/4b227eeec43817465ca835ca66f75e2b>`_ is a "
"Gist which provides the bare-bones files to run the above functionality "
"using Supervisor: you will need to change the ``/path/to/`` parts in the "
"Gist to reflect the actual paths you want to use."
msgstr ""
"Para ejecutar un logging oyente en producción, es posible que tenga que "
"utilizar una herramienta de gestión de procesos como `Supervisor <http://"
"supervisord.org/>`_. `Aquí <https://gist.github.com/"
"vsajip/4b227eeec43817465ca835ca66f75e2b>`_ hay un Gist que proporciona los "
"archivos básicos para ejecutar la funcionalidad anterior utilizando "
"Supervisor: tendrá que cambiar las partes ``/path/to/`` en el Gist para "
"reflejar las rutas reales que desea utilizar."

#: ../Doc/howto/logging-cookbook.rst:779
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:781
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:796
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:798
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:806
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:822
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:831
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:847
msgid "which you can use like this::"
msgstr "que puede usar así::"

#: ../Doc/howto/logging-cookbook.rst:852
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:856
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:858
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:867
msgid "Using Filters to impart contextual information"
msgstr "Usar filtros para impartir información contextual"

#: ../Doc/howto/logging-cookbook.rst:869
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:874
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:920
msgid "which, when run, produces something like:"
msgstr "que cuando se ejecuta, produce algo como:"

#: ../Doc/howto/logging-cookbook.rst:938
msgid "Use of ``contextvars``"
msgstr "Uso de ``contextvars``"

#: ../Doc/howto/logging-cookbook.rst:940
msgid ""
"Since Python 3.7, the :mod:`contextvars` module has provided context-local "
"storage which works for both :mod:`threading` and :mod:`asyncio` processing "
"needs. This type of storage may thus be generally preferable to thread-"
"locals. The following example shows how, in a multi-threaded environment, "
"logs can populated with contextual information such as, for example, request "
"attributes handled by web applications."
msgstr ""
"Desde la versión 3.7 de Python, el módulo :mod:`contextvars` ha "
"proporcionado almacenamiento local de contexto que funciona tanto para las "
"necesidades de procesamiento de :mod:`threading` como de :mod:`asyncio`. "
"Este tipo de almacenamiento puede ser, por tanto, preferible a los hilos "
"locales. El siguiente ejemplo muestra cómo, en un entorno multihilo, los "
"logs pueden rellenarse con información contextual como, por ejemplo, los "
"atributos de las peticiones gestionadas por las aplicaciones web."

#: ../Doc/howto/logging-cookbook.rst:946
msgid ""
"For the purposes of illustration, say that you have different web "
"applications, each independent of the other but running in the same Python "
"process and using a library common to them. How can each of these "
"applications have their own log, where all logging messages from the library "
"(and other request processing code) are directed to the appropriate "
"application's log file, while including in the log additional contextual "
"information such as client IP, HTTP request method and client username?"
msgstr ""
"A modo de ilustración, digamos que tienes diferentes aplicaciones web, cada "
"una de ellas independiente de la otra, pero que se ejecutan en el mismo "
"proceso de Python y utilizan una biblioteca común a todas ellas. ¿Cómo puede "
"cada una de estas aplicaciones tener su propio registro, donde todos los "
"mensajes de logging de la biblioteca (y otro código de procesamiento de "
"solicitudes) se dirigen al archivo de registro de la aplicación apropiada, "
"mientras se incluye en el registro información contextual adicional como la "
"IP del cliente, el método de solicitud HTTP y el nombre de usuario del "
"cliente?"

#: ../Doc/howto/logging-cookbook.rst:953
msgid "Let's assume that the library can be simulated by the following code:"
msgstr "Supongamos que la biblioteca se puede simular con el siguiente código:"

#: ../Doc/howto/logging-cookbook.rst:969
msgid ""
"We can simulate the multiple web applications by means of two simple "
"classes, ``Request`` and ``WebApp``. These simulate how real threaded web "
"applications work - each request is handled by a thread:"
msgstr ""
"Podemos simular las aplicaciones web múltiples mediante dos clases simples, "
"``Request`` y ``WebApp``. Éstas simulan cómo funcionan las aplicaciones web "
"reales con hilos, cada petición es manejada por un hilo:"

#: ../Doc/howto/logging-cookbook.rst:1113
msgid ""
"If you run the above, you should find that roughly half the requests go "
"into :file:`app1.log` and the rest into :file:`app2.log`, and the all the "
"requests are logged to :file:`app.log`. Each webapp-specific log will "
"contain only log entries for only that webapp, and the request information "
"will be displayed consistently in the log (i.e. the information in each "
"dummy request will always appear together in a log line). This is "
"illustrated by the following shell output:"
msgstr ""
"Si ejecuta lo anterior, debería encontrar que aproximadamente la mitad de "
"las peticiones van a :file:`app1.log` y el resto a :file:`app2.log`, y las "
"todas las peticiones se registran en :file:`app.log`. Cada registro "
"específico de la aplicación web contendrá únicamente entradas de log para "
"esa aplicación web, y la información de las peticiones se mostrará de forma "
"consistente en el registro (es decir, la información de cada petición "
"ficticia aparecerá siempre junta en una línea de log). Esto se ilustra con "
"la siguiente salida del shell:"

#: ../Doc/howto/logging-cookbook.rst:1160
msgid "Imparting contextual information in handlers"
msgstr "Impartir información contextual en los gestores"

#: ../Doc/howto/logging-cookbook.rst:1162
msgid ""
"Each :class:`~Handler` has its own chain of filters. If you want to add "
"contextual information to a :class:`LogRecord` without leaking it to other "
"handlers, you can use a filter that returns a new :class:`~LogRecord` "
"instead of modifying it in-place, as shown in the following script::"
msgstr ""
"Cada :class:`~Handler` tiene su propia cadena de filtros. Si quieres añadir "
"información contextual a una :class:`LogRecord` sin filtrarla a otros "
"gestores, puedes utilizar un filtro que retorna una nueva :class:"
"`~LogRecord` en lugar de modificarlo in situ, como se muestra en el "
"siguiente script::"

#: ../Doc/howto/logging-cookbook.rst:1189
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:1191
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:1204
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:1214
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:1330
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:1425
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:1432
msgid "Using concurrent.futures.ProcessPoolExecutor"
msgstr "Usando concurrent.futures.ProcessPoolExecutor"

#: ../Doc/howto/logging-cookbook.rst:1434
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:1442
msgid "you should use"
msgstr "debería usar"

#: ../Doc/howto/logging-cookbook.rst:1448
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:1459
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:1466
msgid "Deploying Web applications using Gunicorn and uWSGI"
msgstr "Despliegue de aplicaciones web con Gunicorn y uWSGI"

#: ../Doc/howto/logging-cookbook.rst:1468
msgid ""
"When deploying Web applications using `Gunicorn <https://gunicorn.org/>`_ or "
"`uWSGI <https://uwsgi-docs.readthedocs.io/en/latest/>`_ (or similar), "
"multiple worker processes are created to handle client requests. In such "
"environments, avoid creating file-based handlers directly in your web "
"application. Instead, use a :class:`SocketHandler` to log from the web "
"application to a listener in a separate process. This can be set up using a "
"process management tool such as Supervisor - see `Running a logging socket "
"listener in production`_ for more details."
msgstr ""
"Cuando se despliegan aplicaciones web utilizando `Gunicorn <https://gunicorn."
"org/>`_ o `uWSGI <https://uwsgi-docs.readthedocs.io/en/latest/>`_ (o "
"similares), se crean múltiples procesos de trabajo para gestionar las "
"peticiones de los clientes. En estos entornos, evite crear gestores basados "
"directamente en archivos en su aplicación web. En su lugar, utilice un :"
"class:`SocketHandler` para registrar desde la aplicación web al oyente en un "
"proceso separado. Esto puede configurarse usando una herramienta de gestión "
"de procesos como Supervisor - vea `Running a logging socket listener in "
"production`_ para más detalles."

#: ../Doc/howto/logging-cookbook.rst:1478
msgid "Using file rotation"
msgstr "Usando rotación de archivos"

#: ../Doc/howto/logging-cookbook.rst:1483
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:1515
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:1527
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:1532
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:1538
msgid "Use of alternative formatting styles"
msgstr "Uso de estilos de formato alternativos"

#: ../Doc/howto/logging-cookbook.rst:1540
#, python-format
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:1546
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:1580
#, python-format
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í:"

#: ../Doc/howto/logging-cookbook.rst:1588
#, python-format
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:1601
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:1625
#, python-format
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:1633
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:1655
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:1659
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:1667
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:1698
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:1707
msgid "Customizing ``LogRecord``"
msgstr "Personalización de ``LogRecord``"

#: ../Doc/howto/logging-cookbook.rst:1709
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:1716
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:1719
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:1725
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:1728
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:1731
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:1735
msgid ""
"The first approach would be a little unwieldy in the scenario where (say) "
"several different libraries wanted to do different things. Each would "
"attempt to set its own :class:`Logger` subclass, and the one which did this "
"last would win."
msgstr ""
"El primer enfoque sería un poco difícil de manejar en el escenario en el que "
"(digamos) varias bibliotecas diferentes quisieran hacer cosas diferentes. "
"Cada uno intentaría establecer su propia subclase :class:`Logger`, y el que "
"hiciera esto último ganaría."

#: ../Doc/howto/logging-cookbook.rst:1740
msgid ""
"The second approach works reasonably well for many cases, but does not allow "
"you to e.g. use a specialized subclass of :class:`LogRecord`. Library "
"developers can set a suitable filter on their loggers, but they would have "
"to remember to do this every time they introduced a new logger (which they "
"would do simply by adding new packages or modules and doing ::"
msgstr ""
"El segundo enfoque funciona razonablemente bien en muchos casos, pero no le "
"permite, por ejemplo, usar una subclase especializada de :class:`LogRecord`. "
"Los desarrolladores de bibliotecas pueden establecer un filtro adecuado en "
"sus registradores, pero tendrían que recordar hacerlo cada vez que "
"introduzcan un nuevo registrador (lo que harían simplemente agregando nuevos "
"paquetes o módulos y haciendo ::"

#: ../Doc/howto/logging-cookbook.rst:1748
msgid ""
"at module level). It's probably one too many things to think about. "
"Developers could also add the filter to a :class:`~logging.NullHandler` "
"attached to their top-level logger, but this would not be invoked if an "
"application developer attached a handler to a lower-level library logger --- "
"so output from that handler would not reflect the intentions of the library "
"developer."
msgstr ""
"a nivel de módulo). Probablemente sean demasiadas cosas en las que pensar. "
"Los desarrolladores también podrían agregar el filtro a :class:`~logging."
"NullHandler` adjunto a su registrador de nivel superior, pero esto no se "
"invocaría si un desarrollador de aplicaciones adjuntara un controlador a un "
"registrador de biblioteca de nivel inferior --- así que la salida de ese "
"gestor no reflejaría las intenciones del desarrollador de la biblioteca."

#: ../Doc/howto/logging-cookbook.rst:1754
msgid ""
"In Python 3.2 and later, :class:`~logging.LogRecord` creation is done "
"through a factory, which you can specify. The factory is just a callable you "
"can set with :func:`~logging.setLogRecordFactory`, and interrogate with :"
"func:`~logging.getLogRecordFactory`. The factory is invoked with the same "
"signature as the :class:`~logging.LogRecord` constructor, as :class:"
"`LogRecord` is the default setting for the factory."
msgstr ""
"En Python 3.2 y posteriores, la creación de :class:`~logging.LogRecord` se "
"realiza a través de una fábrica, que puede especificar. La fábrica es "
"simplemente un invocable que puede configurar con :func:`~logging."
"setLogRecordFactory`, e interrogar con :func:`~logging.getLogRecordFactory`. "
"La fábrica se invoca con la misma firma que el constructor :class:`~logging."
"LogRecord`, ya que :class:`LogRecord` es la configuración predeterminada de "
"la fábrica."

#: ../Doc/howto/logging-cookbook.rst:1761
msgid ""
"This approach allows a custom factory to control all aspects of LogRecord "
"creation. For example, you could return a subclass, or just add some "
"additional attributes to the record once created, using a pattern similar to "
"this::"
msgstr ""
"Este enfoque permite que una fábrica personalizada controle todos los "
"aspectos de la creación de *LogRecord*. Por ejemplo, podría devolver una "
"subclase, o simplemente agregar algunos atributos adicionales al registro "
"una vez creado, usando un patrón similar a este::"

#: ../Doc/howto/logging-cookbook.rst:1774
msgid ""
"This pattern allows different libraries to chain factories together, and as "
"long as they don't overwrite each other's attributes or unintentionally "
"overwrite the attributes provided as standard, there should be no surprises. "
"However, it should be borne in mind that each link in the chain adds run-"
"time overhead to all logging operations, and the technique should only be "
"used when the use of a :class:`Filter` does not provide the desired result."
msgstr ""
"Este patrón permite que diferentes bibliotecas encadenen fábricas juntas, y "
"siempre que no sobrescriban los atributos de las demás o sobrescriban "
"involuntariamente los atributos proporcionados como estándar, no debería "
"haber sorpresas. Sin embargo, debe tenerse en cuenta que cada eslabón de la "
"cadena agrega una sobrecarga de tiempo de ejecución a todas las operaciones "
"de logging, y la técnica solo debe usarse cuando el uso de :class:`Filter` "
"no proporciona el resultado deseado."

#: ../Doc/howto/logging-cookbook.rst:1785
msgid "Subclassing QueueHandler - a ZeroMQ example"
msgstr "Subclasificación QueueHandler - un ejemplo de ZeroMQ"

#: ../Doc/howto/logging-cookbook.rst:1787
msgid ""
"You can use a :class:`QueueHandler` subclass to send messages to other kinds "
"of queues, for example a ZeroMQ 'publish' socket. In the example below,the "
"socket is created separately and passed to the handler (as its 'queue')::"
msgstr ""
"Puede usar una subclase :class:`QueueHandler` para enviar mensajes a otros "
"tipos de colas, por ejemplo, un socket de 'publicación' ZeroMQ. En el "
"siguiente ejemplo, el socket se crea por separado y se pasa al gestor (como "
"su 'cola')::"

#: ../Doc/howto/logging-cookbook.rst:1806
msgid ""
"Of course there are other ways of organizing this, for example passing in "
"the data needed by the handler to create the socket::"
msgstr ""
"Por supuesto, hay otras formas de organizar esto, por ejemplo, pasando los "
"datos que necesita el gestor para crear el socket::"

#: ../Doc/howto/logging-cookbook.rst:1824
msgid "Subclassing QueueListener - a ZeroMQ example"
msgstr "Subclasificación QueueListener - un ejemplo de ZeroMQ"

#: ../Doc/howto/logging-cookbook.rst:1826
msgid ""
"You can also subclass :class:`QueueListener` to get messages from other "
"kinds of queues, for example a ZeroMQ 'subscribe' socket. Here's an example::"
msgstr ""
"También puede subclasificar :class:`QueueListener` para obtener mensajes de "
"otros tipos de colas, por ejemplo, un socket de 'suscripción' de ZeroMQ. "
"Aquí tienes un ejemplo::"

#: ../Doc/howto/logging-cookbook.rst:1845
#: ../Doc/howto/logging-cookbook.rst:3865
msgid "Module :mod:`logging`"
msgstr "Módulo :mod:`logging`"

#: ../Doc/howto/logging-cookbook.rst:1845
#: ../Doc/howto/logging-cookbook.rst:3865
msgid "API reference for the logging module."
msgstr "Referencia de API para el módulo logging."

#: ../Doc/howto/logging-cookbook.rst:1848
#: ../Doc/howto/logging-cookbook.rst:3868
msgid "Module :mod:`logging.config`"
msgstr "Módulo :mod:`logging.config`"

#: ../Doc/howto/logging-cookbook.rst:1848
#: ../Doc/howto/logging-cookbook.rst:3868
msgid "Configuration API for the logging module."
msgstr "API de configuración para el módulo logging."

#: ../Doc/howto/logging-cookbook.rst:1851
#: ../Doc/howto/logging-cookbook.rst:3871
msgid "Module :mod:`logging.handlers`"
msgstr "Módulo :mod:`logging.handlers`"

#: ../Doc/howto/logging-cookbook.rst:1851
#: ../Doc/howto/logging-cookbook.rst:3871
msgid "Useful handlers included with the logging module."
msgstr "Gestores útiles incluidos con el módulo logging."

#: ../Doc/howto/logging-cookbook.rst:1853
msgid ":ref:`A basic logging tutorial <logging-basic-tutorial>`"
msgstr ":ref:`Un tutorial básico de logging <logging-basic-tutorial>`"

#: ../Doc/howto/logging-cookbook.rst:1855
msgid ":ref:`A more advanced logging tutorial <logging-advanced-tutorial>`"
msgstr ":ref:`Un tutorial de logging más avanzado <logging-advanced-tutorial>`"

#: ../Doc/howto/logging-cookbook.rst:1859
msgid "An example dictionary-based configuration"
msgstr "Una configuración de ejemplo basada en diccionario"

#: ../Doc/howto/logging-cookbook.rst:1861
msgid ""
"Below is an example of a logging configuration dictionary - it's taken from "
"the `documentation on the Django project <https://docs.djangoproject.com/en/"
"stable/topics/logging/#configuring-logging>`_. This dictionary is passed to :"
"func:`~config.dictConfig` to put the configuration into effect::"
msgstr ""
"A continuación se muestra un ejemplo de un diccionario de configuración de "
"logging, tomado de la `documentación del proyecto Django <https://docs."
"djangoproject.com/en/1.9/topics/logging/#configuring-logging>`_. Este "
"diccionario se pasa a :func:`~config.dictConfig` para poner en efecto la "
"configuración::"

#: ../Doc/howto/logging-cookbook.rst:1917
msgid ""
"For more information about this configuration, you can see the `relevant "
"section <https://docs.djangoproject.com/en/stable/topics/logging/"
"#configuring-logging>`_ of the Django documentation."
msgstr ""
"Para obtener más información sobre esta configuración, puede ver la `sección "
"correspondiente <https://docs.djangoproject.com/en/1.9/topics/logging/"
"#configuring-logging>`_ de la documentación de Django."

#: ../Doc/howto/logging-cookbook.rst:1924
msgid "Using a rotator and namer to customize log rotation processing"
msgstr ""
"Usar un rotador y un nombre para personalizar el procesamiento de rotación "
"de log"

#: ../Doc/howto/logging-cookbook.rst:1926
msgid ""
"An example of how you can define a namer and rotator is given in the "
"following snippet, which shows zlib-based compression of the log file::"
msgstr ""
"Un ejemplo de cómo puede definir un nombre y un rotador se da en el "
"siguiente fragmento, que muestra la compresión basada en zlib del archivo de "
"log::"

#: ../Doc/howto/logging-cookbook.rst:1944
msgid ""
"These are not \"true\" .gz files, as they are bare compressed data, with no "
"\"container\" such as you’d find in an actual gzip file. This snippet is "
"just for illustration purposes."
msgstr ""
"Estos no son archivos .gz \"verdaderos\", ya que son datos comprimidos sin "
"ningún \"contenedor\" como el que encontraría en un archivo gzip real. Este "
"fragmento es solo para fines ilustrativos."

#: ../Doc/howto/logging-cookbook.rst:1949
msgid "A more elaborate multiprocessing example"
msgstr "Un ejemplo de multiprocesamiento más elaborado"

#: ../Doc/howto/logging-cookbook.rst:1951
msgid ""
"The following working example shows how logging can be used with "
"multiprocessing using configuration files. The configurations are fairly "
"simple, but serve to illustrate how more complex ones could be implemented "
"in a real multiprocessing scenario."
msgstr ""
"El siguiente ejemplo de trabajo muestra cómo logging se puede usar con "
"multiprocesamiento usando archivos de configuración. Las configuraciones son "
"bastante simples, pero sirven para ilustrar cómo se podrían implementar las "
"más complejas en un escenario real de multiprocesamiento."

#: ../Doc/howto/logging-cookbook.rst:1956
msgid ""
"In the example, the main process spawns a listener process and some worker "
"processes. Each of the main process, the listener and the workers have three "
"separate configurations (the workers all share the same configuration). We "
"can see logging in the main process, how the workers log to a QueueHandler "
"and how the listener implements a QueueListener and a more complex logging "
"configuration, and arranges to dispatch events received via the queue to the "
"handlers specified in the configuration. Note that these configurations are "
"purely illustrative, but you should be able to adapt this example to your "
"own scenario."
msgstr ""
"En el ejemplo, el proceso principal genera un proceso de escucha y algunos "
"procesos de trabajo. Cada uno de los procesos principales, el oyente y los "
"trabajadores tienen tres configuraciones separadas (todos los trabajadores "
"comparten la misma configuración). Podemos ver el registro en el proceso "
"principal, cómo los trabajadores se registran en un QueueHandler y cómo el "
"oyente implementa un QueueListener y una configuración de registro más "
"compleja, y organiza el envío de eventos recibidos a través de la cola a los "
"controladores especificados en la configuración. Tenga en cuenta que estas "
"configuraciones son puramente ilustrativas, pero debería poder adaptar este "
"ejemplo a su propio escenario."

#: ../Doc/howto/logging-cookbook.rst:1966
msgid ""
"Here's the script - the docstrings and the comments hopefully explain how it "
"works::"
msgstr ""
"Aquí está el script, el docstrings y los comentarios, esperemos, expliquen "
"cómo funciona::"

#: ../Doc/howto/logging-cookbook.rst:2178
msgid "Inserting a BOM into messages sent to a SysLogHandler"
msgstr "Insertar BOM en mensajes enviados a SysLogHandler"

#: ../Doc/howto/logging-cookbook.rst:2180
msgid ""
":rfc:`5424` requires that a Unicode message be sent to a syslog daemon as a "
"set of bytes which have the following structure: an optional pure-ASCII "
"component, followed by a UTF-8 Byte Order Mark (BOM), followed by Unicode "
"encoded using UTF-8. (See the :rfc:`relevant section of the specification "
"<5424#section-6>`.)"
msgstr ""
":rfc:`5424` requiere que se envíe un mensaje Unicode a un demonio syslog "
"como un conjunto de bytes que tienen la siguiente estructura: un componente "
"opcional ASCII puro, seguido de una marca de orden de bytes UTF-8 (BOM), "
"seguida de Codificado en Unicode usando UTF-8. (Ver sección relevante de la "
"especificación :rfc:`5424#section-6`.)"

#: ../Doc/howto/logging-cookbook.rst:2186
msgid ""
"In Python 3.1, code was added to :class:`~logging.handlers.SysLogHandler` to "
"insert a BOM into the message, but unfortunately, it was implemented "
"incorrectly, with the BOM appearing at the beginning of the message and "
"hence not allowing any pure-ASCII component to appear before it."
msgstr ""
"En Python 3.1, se agregó código a :class:`~logging.handlers.SysLogHandler` "
"para insertar BOM en el mensaje, pero desafortunadamente, se implementó "
"incorrectamente, BOM aparece al principio del mensaje y, por lo tanto, no "
"permite ningún componente ASCII puro para que aparezca antes."

#: ../Doc/howto/logging-cookbook.rst:2192
msgid ""
"As this behaviour is broken, the incorrect BOM insertion code is being "
"removed from Python 3.2.4 and later. However, it is not being replaced, and "
"if you want to produce :rfc:`5424`-compliant messages which include a BOM, "
"an optional pure-ASCII sequence before it and arbitrary Unicode after it, "
"encoded using UTF-8, then you need to do the following:"
msgstr ""
"Como este comportamiento no funciona, el código de inserción BOM incorrecto "
"se elimina de Python 3.2.4 y versiones posteriores. Sin embargo, no se está "
"reemplazando, y si desea producir mensajes compatibles con :rfc:`5424` que "
"incluyan BOM, una secuencia opcional de ASCII puro antes y Unicode "
"arbitrario después, codificados usando UTF-8; entonces necesita hacer lo "
"siguiente:"

#: ../Doc/howto/logging-cookbook.rst:2198
msgid ""
"Attach a :class:`~logging.Formatter` instance to your :class:`~logging."
"handlers.SysLogHandler` instance, with a format string such as::"
msgstr ""
"Adjunte una instancia de :class:`~logging.Formatter` a su instancia :class:"
"`~logging.handlers.SysLogHandler`, con una cadena de caracteres de formato "
"como::"

#: ../Doc/howto/logging-cookbook.rst:2204
msgid ""
"The Unicode code point U+FEFF, when encoded using UTF-8, will be encoded as "
"a UTF-8 BOM -- the byte-string ``b'\\xef\\xbb\\xbf'``."
msgstr ""
"El punto de código Unicode U+ FEFF, cuando se codifica usando UTF-8, se "
"codificará como una BOM UTF-8, la cadena de bytes ``b'\\xef\\xbb\\xbf'``."

#: ../Doc/howto/logging-cookbook.rst:2207
msgid ""
"Replace the ASCII section with whatever placeholders you like, but make sure "
"that the data that appears in there after substitution is always ASCII (that "
"way, it will remain unchanged after UTF-8 encoding)."
msgstr ""
"Reemplace la sección ASCII con los marcadores de posición que desee, pero "
"asegúrese de que los datos que aparecen allí después de la sustitución sean "
"siempre ASCII (de esa manera, permanecerán sin cambios después de la "
"codificación UTF-8)."

#: ../Doc/howto/logging-cookbook.rst:2211
msgid ""
"Replace the Unicode section with whatever placeholders you like; if the data "
"which appears there after substitution contains characters outside the ASCII "
"range, that's fine -- it will be encoded using UTF-8."
msgstr ""
"Reemplace la sección Unicode con los marcadores de posición que desee; si "
"los datos que aparecen allí después de la sustitución contienen caracteres "
"fuera del rango ASCII, está bien: se codificarán usando UTF-8."

#: ../Doc/howto/logging-cookbook.rst:2215
msgid ""
"The formatted message *will* be encoded using UTF-8 encoding by "
"``SysLogHandler``. If you follow the above rules, you should be able to "
"produce :rfc:`5424`-compliant messages. If you don't, logging may not "
"complain, but your messages will not be RFC 5424-compliant, and your syslog "
"daemon may complain."
msgstr ""
"El mensaje formateado *se* codificará utilizando la codificación UTF-8 por "
"``SysLogHandler``. Si sigue las reglas anteriores, debería poder producir "
"mensajes compatibles con :rfc:`5424`. Si no lo hace, es posible que el "
"logging no se queje, pero sus mensajes no serán compatibles con RFC 5424 y "
"su demonio syslog puede quejarse."

#: ../Doc/howto/logging-cookbook.rst:2222
msgid "Implementing structured logging"
msgstr "Implementar logging estructurado"

#: ../Doc/howto/logging-cookbook.rst:2224
msgid ""
"Although most logging messages are intended for reading by humans, and thus "
"not readily machine-parseable, there might be circumstances where you want "
"to output messages in a structured format which *is* capable of being parsed "
"by a program (without needing complex regular expressions to parse the log "
"message). This is straightforward to achieve using the logging package. "
"There are a number of ways in which this could be achieved, but the "
"following is a simple approach which uses JSON to serialise the event in a "
"machine-parseable manner::"
msgstr ""
"Aunque la mayoría de los mensajes de registro están destinados a ser leídos "
"por humanos y, por lo tanto, no se pueden analizar fácilmente mediante una "
"máquina, puede haber circunstancias en las que desee generar mensajes en un "
"formato estructurado que *sea* capaz de ser analizado por un programa (sin "
"necesidad de expresiones regulares complejas para analizar el mensaje de "
"registro). Esto es sencillo de lograr utilizando el paquete de registro. Hay "
"varias formas de lograr esto, pero el siguiente es un enfoque simple que usa "
"JSON para serializar el evento de una manera analizable por máquina:"

#: ../Doc/howto/logging-cookbook.rst:2248
msgid "If the above script is run, it prints:"
msgstr "Si se ejecuta el script anterior, se imprime:"

#: ../Doc/howto/logging-cookbook.rst:2254
#: ../Doc/howto/logging-cookbook.rst:2296
msgid ""
"Note that the order of items might be different according to the version of "
"Python used."
msgstr ""
"Tenga en cuenta que el orden de los elementos puede ser diferente según la "
"versión de Python utilizada."

#: ../Doc/howto/logging-cookbook.rst:2257
msgid ""
"If you need more specialised processing, you can use a custom JSON encoder, "
"as in the following complete example::"
msgstr ""
"Si necesita un procesamiento más especializado, puede utilizar un "
"codificador JSON personalizado, como en el siguiente ejemplo completo::"

#: ../Doc/howto/logging-cookbook.rst:2290
msgid "When the above script is run, it prints:"
msgstr "Cuando se ejecuta el script anterior, se imprime:"

#: ../Doc/howto/logging-cookbook.rst:2305
msgid "Customizing handlers with :func:`dictConfig`"
msgstr "Personalización de gestores con :func:`dictConfig`"

#: ../Doc/howto/logging-cookbook.rst:2307
msgid ""
"There are times when you want to customize logging handlers in particular "
"ways, and if you use :func:`dictConfig` you may be able to do this without "
"subclassing. As an example, consider that you may want to set the ownership "
"of a log file. On POSIX, this is easily done using :func:`shutil.chown`, but "
"the file handlers in the stdlib don't offer built-in support. You can "
"customize handler creation using a plain function such as::"
msgstr ""
"Hay ocasiones en las que desea personalizar los gestores de logging de "
"formas particulares, y si usa :func:`dictConfig` puede hacerlo sin "
"subclases. Como ejemplo, considere que es posible que desee establecer la "
"propiedad de un archivo de log. En POSIX, esto se hace fácilmente usando :"
"func:`shutil.chown`, pero los gestores de archivos en stdlib no ofrecen "
"soporte integrado. Puede personalizar la creación de gestores usando una "
"función simple como::"

#: ../Doc/howto/logging-cookbook.rst:2321
msgid ""
"You can then specify, in a logging configuration passed to :func:"
"`dictConfig`, that a logging handler be created by calling this function::"
msgstr ""
"Luego puede especificar, en una configuración de logging pasada a :func:"
"`dictConfig`, que se cree un gestor de logging llamando a esta función::"

#: ../Doc/howto/logging-cookbook.rst:2354
msgid ""
"In this example I am setting the ownership using the ``pulse`` user and "
"group, just for the purposes of illustration. Putting it together into a "
"working script, ``chowntest.py``::"
msgstr ""
"En este ejemplo, se establece la propiedad utilizando el usuario y el grupo "
"``pulse``, solo con fines ilustrativos. Poniéndolo junto en un script de "
"trabajo, ``chowntest.py``::"

#: ../Doc/howto/logging-cookbook.rst:2401
msgid "To run this, you will probably need to run as ``root``:"
msgstr ""
"Para ejecutar esto, probablemente se necesite ejecutarlo como ``root``:"

#: ../Doc/howto/logging-cookbook.rst:2411
msgid ""
"Note that this example uses Python 3.3 because that's where :func:`shutil."
"chown` makes an appearance. This approach should work with any Python "
"version that supports :func:`dictConfig` - namely, Python 2.7, 3.2 or later. "
"With pre-3.3 versions, you would need to implement the actual ownership "
"change using e.g. :func:`os.chown`."
msgstr ""
"Tenga en cuenta que este ejemplo usa Python 3.3 porque ahí es donde :func:"
"`shutil.chown` aparece. Este enfoque debería funcionar con cualquier versión "
"de Python que admita :func:`dictConfig`, es decir, Python 2.7, 3.2 o "
"posterior. Con las versiones anteriores a 3.3, necesitaría implementar el "
"cambio de propiedad real usando, por ejemplo, :func:`os.chown`."

#: ../Doc/howto/logging-cookbook.rst:2417
msgid ""
"In practice, the handler-creating function may be in a utility module "
"somewhere in your project. Instead of the line in the configuration::"
msgstr ""
"En la práctica, la función de creación de gestores puede estar en un módulo "
"de utilidad en algún lugar de su proyecto. En lugar de la línea en la "
"configuración::"

#: ../Doc/howto/logging-cookbook.rst:2422
msgid "you could use e.g.::"
msgstr "podrías usar, por ejemplo,::"

#: ../Doc/howto/logging-cookbook.rst:2426
msgid ""
"where ``project.util`` can be replaced with the actual name of the package "
"where the function resides. In the above working script, using ``'ext://"
"__main__.owned_file_handler'`` should work. Here, the actual callable is "
"resolved by :func:`dictConfig` from the ``ext://`` specification."
msgstr ""
"donde ``project.util`` se puede reemplazar con el nombre real del paquete "
"donde reside la función. En el script de trabajo anterior, el uso de "
"``'ext://__main__.owned_file_handler'`` debería funcionar. Aquí, el "
"invocable real se resuelve mediante :func:`dictConfig` de la especificación "
"``ext://``."

#: ../Doc/howto/logging-cookbook.rst:2431
msgid ""
"This example hopefully also points the way to how you could implement other "
"types of file change - e.g. setting specific POSIX permission bits - in the "
"same way, using :func:`os.chmod`."
msgstr ""
"Por fortuna, este ejemplo también indica el camino hacia cómo podría "
"implementar otros tipos de cambio de archivo, por ejemplo, configurando de "
"la misma manera bits de permisos POSIX específicos, usando :func:`os.chmod`."

#: ../Doc/howto/logging-cookbook.rst:2435
msgid ""
"Of course, the approach could also be extended to types of handler other "
"than a :class:`~logging.FileHandler` - for example, one of the rotating file "
"handlers, or a different type of handler altogether."
msgstr ""
"Por supuesto, el enfoque también podría extenderse a tipos de gestores "
"distintos a :class:`~logging.FileHandler` - por ejemplo, uno de los gestores "
"de archivos rotativos, o un tipo diferente por completo."

#: ../Doc/howto/logging-cookbook.rst:2445
msgid "Using particular formatting styles throughout your application"
msgstr "Usar estilos de formato particulares en toda su aplicación"

#: ../Doc/howto/logging-cookbook.rst:2447
msgid ""
"In Python 3.2, the :class:`~logging.Formatter` gained a ``style`` keyword "
"parameter which, while defaulting to ``%`` for backward compatibility, "
"allowed the specification of ``{`` or ``$`` to support the formatting "
"approaches supported by :meth:`str.format` and :class:`string.Template`. "
"Note that this governs the formatting of logging messages for final output "
"to logs, and is completely orthogonal to how an individual logging message "
"is constructed."
msgstr ""
"En Python 3.2, :class:`~logging.Formatter` obtuvo un parámetro de palabra "
"clave ``estilo`` que, aunque por defecto era ``%`` para compatibilidad con "
"versiones anteriores, permitía la especificación de ``{`` o ``$`` para "
"permitir los enfoques de formato admitidos por :meth:`str.format` y :class:"
"`string.Template`. Tenga en cuenta que esto rige el formato de los mensajes "
"de logging para la salida final a los logging y es completamente ortogonal a "
"cómo se construye un mensaje de logging individual."

#: ../Doc/howto/logging-cookbook.rst:2454
#, python-format
msgid ""
"Logging calls (:meth:`~Logger.debug`, :meth:`~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 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 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 (:meth:`~Logger.debug`, :meth:`~Logger.info`, etc.) "
"solo toman parámetros posicionales para el mensaje logging real en sí, con "
"parámetros de palabras clave que se utilizan solo para determinar las "
"opciones sobre cómo gestionar la llamada de 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 logging usa formato % para fusionar la cadena de formato y los "
"argumentos de las variables. No se cambiaría esto mientras se conserve la "
"compatibilidad con versiones anteriores, ya que todas las llamadas de "
"logging que están en el código existente utilizarán cadenas de caracteres "
"formato %."

#: ../Doc/howto/logging-cookbook.rst:2466
#, python-format
msgid ""
"There have been suggestions to associate format styles with specific "
"loggers, but that approach also runs into backward compatibility problems "
"because any existing code could be using a given logger name and using "
"%-formatting."
msgstr ""
"Ha habido sugerencias para asociar estilos de formato con *loggers* "
"específicos, pero ese enfoque también tiene problemas de compatibilidad con "
"versiones anteriores porque cualquier código existente podría estar usando "
"un nombre de *logger* dado y usando formato %."

#: ../Doc/howto/logging-cookbook.rst:2470
msgid ""
"For logging to work interoperably between any third-party libraries and your "
"code, decisions about formatting need to be made at the level of the "
"individual logging call. This opens up a couple of ways in which alternative "
"formatting styles can be accommodated."
msgstr ""
"Para que logging funcione de manera interoperable entre cualquier biblioteca "
"de terceros y su código, las decisiones sobre el formato deben tomarse a "
"nivel de la llamada de logging individual. Esto abre un par de formas en las "
"que se pueden acomodar estilos de formato alternativos."

#: ../Doc/howto/logging-cookbook.rst:2477
msgid "Using LogRecord factories"
msgstr "Uso de fábricas de LogRecord"

#: ../Doc/howto/logging-cookbook.rst:2479
#, python-format
msgid ""
"In Python 3.2, along with the :class:`~logging.Formatter` changes mentioned "
"above, the logging package gained the ability to allow users to set their "
"own :class:`LogRecord` subclasses, using the :func:`setLogRecordFactory` "
"function. You can use this to set your own subclass of :class:`LogRecord`, "
"which does the Right Thing by overriding the :meth:`~LogRecord.getMessage` "
"method. The base class implementation of this method is where the ``msg % "
"args`` formatting happens, and where you can substitute your alternate "
"formatting; however, you should be careful to support all formatting styles "
"and allow %-formatting as the default, to ensure interoperability with other "
"code. Care should also be taken to call ``str(self.msg)``, just as the base "
"implementation does."
msgstr ""
"En Python 3.2, junto con los cambios de :class:`~logging.Formatter` "
"mencionados anteriormente, el paquete logging ganó la capacidad de permitir "
"a los usuarios establecer sus propias subclases :class:`LogRecord`, usando "
"la función :func:`setLogRecordFactory`. Puede usar esto para configurar su "
"propia subclase de :class:`LogRecord`, que hace lo correcto al anular el "
"método :meth:`~LogRecord.getMessage`. La implementación de la clase base de "
"este método es donde ocurre el formato ``msg % args`` y donde puede "
"sustituir su formato alternativo; sin embargo, debe tener cuidado de admitir "
"todos los estilos de formato y permitir formato % como predeterminado, para "
"garantizar la interoperabilidad con otro código. También se debe tener "
"cuidado de llamar a ``str(self.msg)``, tal como lo hace la implementación "
"base."

#: ../Doc/howto/logging-cookbook.rst:2490
msgid ""
"Refer to the reference documentation on :func:`setLogRecordFactory` and :"
"class:`LogRecord` for more information."
msgstr ""
"Consulte la documentación de referencia en :func:`setLogRecordFactory` y :"
"class:`LogRecord` para obtener más información."

#: ../Doc/howto/logging-cookbook.rst:2495
msgid "Using custom message objects"
msgstr "Usar objetos de mensaje personalizados"

#: ../Doc/howto/logging-cookbook.rst:2497
msgid ""
"There is another, perhaps simpler way that you can use {}- and $- formatting "
"to construct your individual log messages. You may recall (from :ref:"
"`arbitrary-object-messages`) that when logging you can use an arbitrary "
"object as a message format string, and that the logging package will call :"
"func:`str` on that object to get the actual format string. Consider the "
"following two classes::"
msgstr ""
"Existe otra forma, quizás más sencilla, de usar el formato {} - y $ - para "
"construir sus mensajes de log individuales. Al iniciar sesión, recuerde que "
"puede usar cualquier objeto como una cadena de caracteres de formato de "
"mensaje (:ref:`arbitrary-object-messages`) que al iniciar sesión puede usar "
"un objeto arbitrario como una cadena de formato de mensaje, y que el paquete "
"de logging llamará :func:`str` en ese objeto para obtener el cadena de "
"formato real. Considere las siguientes dos clases:"

#: ../Doc/howto/logging-cookbook.rst:2522
#, python-format
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”. If you find it a little unwieldy to use the class names whenever "
"you want to log something, you can make it more palatable if you use an "
"alias such as ``M`` or ``_`` for the message (or perhaps ``__``, if you are "
"using ``_`` for localization)."
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 formateado en lugar de "
"“%(message)s” or “{message}” or “$message”. Si le resulta un poco difícil de "
"manejar usar los nombres de las clases cada vez que desea registrar algo, "
"puede hacerlo más tolerable si usa un alias como ``M`` o ``_`` para el "
"mensaje (o quizás ``__``, si está utilizando ``_`` para localización)."

#: ../Doc/howto/logging-cookbook.rst:2530
msgid ""
"Examples of this approach are given below. Firstly, formatting with :meth:"
"`str.format`::"
msgstr ""
"A continuación se dan ejemplos de este enfoque. En primer lugar, formatear "
"con :meth:`str.format`::"

#: ../Doc/howto/logging-cookbook.rst:2544
msgid "Secondly, formatting with :class:`string.Template`::"
msgstr "En segundo lugar, formatear con :class:`string.Template`::"

#: ../Doc/howto/logging-cookbook.rst:2551
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 shown "
"above."
msgstr ""
"Una cosa a tener en cuenta es que no paga ninguna penalización significativa "
"del rendimiento con este enfoque: el formato real no se produce cuando se "
"realiza la llamada logging, sino cuando (y si) el mensaje registrado está "
"realmente a punto de ser salida a un log por un gestor. Así que lo único un "
"poco inusual con lo que podría tropezar es que los paréntesis van alrededor "
"de la cadena de caracteres de formato y los argumentos, no sólo la cadena de "
"formato. Esto se debe a que la notación __ es solo azúcar sintáctico para "
"una llamada de constructor a una de las clases ``XXXMessage`` mostradas "
"anteriormente."

#: ../Doc/howto/logging-cookbook.rst:2565
msgid "Configuring filters with :func:`dictConfig`"
msgstr "Configurar filtros con :func:`dictConfig`"

#: ../Doc/howto/logging-cookbook.rst:2567
msgid ""
"You *can* configure filters using :func:`~logging.config.dictConfig`, though "
"it might not be obvious at first glance how to do it (hence this recipe). "
"Since :class:`~logging.Filter` is the only filter class included in the "
"standard library, and it is unlikely to cater to many requirements (it's "
"only there as a base class), you will typically need to define your own :"
"class:`~logging.Filter` subclass with an overridden :meth:`~logging.Filter."
"filter` method. To do this, specify the ``()`` key in the configuration "
"dictionary for the filter, specifying a callable which will be used to "
"create the filter (a class is the most obvious, but you can provide any "
"callable which returns a :class:`~logging.Filter` instance). Here is a "
"complete example::"
msgstr ""
"*Puedes* configurar filtros usando :func:`~logging.config.dictConfig`, "
"aunque a primera vista es posible que no sea obvio cómo hacerlo (de ahí esta "
"receta). Dado que :class:`~logging.Filter` es la única clase de filtro "
"incluida en la biblioteca estándar, y es poco probable que satisfaga muchos "
"requisitos (solo está allí como clase base), normalmente necesitarás definir "
"tu propia subclase :class:`~logging.Filter` con un método :meth:`~logging."
"Filter.filter` sobreescrito. Para hacer esto, especifique la clave ``()`` en "
"el diccionario de configuración para el filtro, especificando un invocable "
"que se usará para crear el filtro (una clase es la más obvia, pero puede "
"proporcionar cualquier invocable que retorne una instancia :class:`~logging."
"Filter`). Aquí hay un ejemplo completo:"

#: ../Doc/howto/logging-cookbook.rst:2620
msgid ""
"This example shows how you can pass configuration data to the callable which "
"constructs the instance, in the form of keyword parameters. When run, the "
"above script will print:"
msgstr ""
"Este ejemplo muestra cómo puede pasar datos de configuración al invocable "
"que construye la instancia, en forma de parámetros de palabras clave. Cuando "
"se ejecuta, se imprimirá el script anterior:"

#: ../Doc/howto/logging-cookbook.rst:2628
msgid "which shows that the filter is working as configured."
msgstr "que muestra que el filtro está funcionando según lo configurado."

#: ../Doc/howto/logging-cookbook.rst:2630
msgid "A couple of extra points to note:"
msgstr "Un par de puntos adicionales a tener en cuenta:"

#: ../Doc/howto/logging-cookbook.rst:2632
msgid ""
"If you can't refer to the callable directly in the configuration (e.g. if it "
"lives in a different module, and you can't import it directly where the "
"configuration dictionary is), you can use the form ``ext://...`` as "
"described in :ref:`logging-config-dict-externalobj`. For example, you could "
"have used the text ``'ext://__main__.MyFilter'`` instead of ``MyFilter`` in "
"the above example."
msgstr ""
"Si no puede hacer referencia al invocable directamente en la configuración "
"(por ejemplo, si vive en un módulo diferente y no puede importarlo "
"directamente donde está el diccionario de configuración), puede usar el "
"formulario ``ext://...`` como se describe en :ref:`logging-config-dict-"
"externalobj`. Por ejemplo, podría haber usado el texto ``'ext://__main__."
"MyFilter'`` en lugar de ``MyFilter`` en el ejemplo anterior."

#: ../Doc/howto/logging-cookbook.rst:2639
msgid ""
"As well as for filters, this technique can also be used to configure custom "
"handlers and formatters. See :ref:`logging-config-dict-userdef` for more "
"information on how logging supports using user-defined objects in its "
"configuration, and see the other cookbook recipe :ref:`custom-handlers` "
"above."
msgstr ""
"Además de los filtros, esta técnica también se puede utilizar para "
"configurar gestores y formateadores personalizados. Consultar :ref:`logging-"
"config-dict-userdef` para obtener más información sobre cómo logging admite "
"el uso de objetos definidos por el usuario en su configuración, y ver arriba "
"la otra receta :ref:`custom-handlers`."

#: ../Doc/howto/logging-cookbook.rst:2648
msgid "Customized exception formatting"
msgstr "Formato de excepción personalizado"

#: ../Doc/howto/logging-cookbook.rst:2650
msgid ""
"There might be times when you want to do customized exception formatting - "
"for argument's sake, let's say you want exactly one line per logged event, "
"even when exception information is present. You can do this with a custom "
"formatter class, as shown in the following example::"
msgstr ""
"Puede haber ocasiones en las que desee personalizar un formato de excepción; "
"por el bien del argumento, digamos que desea exactamente una línea por "
"evento registrado, incluso cuando la información de la excepción está "
"presente. Puede hacer esto con una clase de formateador personalizada, como "
"se muestra en el siguiente ejemplo::"

#: ../Doc/howto/logging-cookbook.rst:2691
msgid "When run, this produces a file with exactly two lines:"
msgstr "Cuando se ejecuta, esto produce un archivo con exactamente dos líneas:"

#: ../Doc/howto/logging-cookbook.rst:2698
msgid ""
"While the above treatment is simplistic, it points the way to how exception "
"information can be formatted to your liking. The :mod:`traceback` module may "
"be helpful for more specialized needs."
msgstr ""
"Si bien el tratamiento anterior es simplista, señala el camino hacia cómo se "
"puede formatear la información de excepción a su gusto. El módulo :mod:"
"`traceback` puede resultar útil para necesidades más especializadas."

#: ../Doc/howto/logging-cookbook.rst:2705
msgid "Speaking logging messages"
msgstr "Mensajes de logging hablantes"

#: ../Doc/howto/logging-cookbook.rst:2707
msgid ""
"There might be situations when it is desirable to have logging messages "
"rendered in an audible rather than a visible format. This is easy to do if "
"you have text-to-speech (TTS) functionality available in your system, even "
"if it doesn't have a Python binding. Most TTS systems have a command line "
"program you can run, and this can be invoked from a handler using :mod:"
"`subprocess`. It's assumed here that TTS command line programs won't expect "
"to interact with users or take a long time to complete, and that the "
"frequency of logged messages will be not so high as to swamp the user with "
"messages, and that it's acceptable to have the messages spoken one at a time "
"rather than concurrently, The example implementation below waits for one "
"message to be spoken before the next is processed, and this might cause "
"other handlers to be kept waiting. Here is a short example showing the "
"approach, which assumes that the ``espeak`` TTS package is available::"
msgstr ""
"Puede haber situaciones en las que sea deseable que los mensajes de logging "
"se presenten en un formato audible en lugar de visible. Esto es fácil de "
"hacer si tiene la funcionalidad de texto a voz (*TTS* por sus siglas en "
"inglés) disponible en su sistema, incluso si no tiene un *binding* Python. "
"La mayoría de los sistemas TTS tienen un programa de línea de comandos que "
"puede ejecutar, y esto puede invocarse desde un gestor usando :mod:"
"`subprocess`. Aquí se asume que los programas de línea de comando TTS no "
"esperarán interactuar con los usuarios o tardarán mucho en completarse, y "
"que la frecuencia de los mensajes registrados no será tan alta como para "
"inundar al usuario con mensajes, y que es aceptable que los mensajes se "
"reproducen uno a la vez en lugar de todos al mismo tiempo. La implementación "
"de ejemplo a continuación espera a que se pronuncie un mensaje antes de que "
"se procese el siguiente, y esto puede hacer que otros gestores se mantengan "
"esperando. Aquí hay un breve ejemplo que muestra el enfoque, que asume que "
"el paquete TTS ``espeak`` está disponible::"

#: ../Doc/howto/logging-cookbook.rst:2749
msgid ""
"When run, this script should say \"Hello\" and then \"Goodbye\" in a female "
"voice."
msgstr ""
"Cuando se ejecute, este script debería decir \"Hola\" y luego \"Adiós\" con "
"voz femenina."

#: ../Doc/howto/logging-cookbook.rst:2751
msgid ""
"The above approach can, of course, be adapted to other TTS systems and even "
"other systems altogether which can process messages via external programs "
"run from a command line."
msgstr ""
"El enfoque anterior puede, por supuesto, adaptarse a otros sistemas TTS e "
"incluso a otros sistemas que pueden procesar mensajes a través de programas "
"externos ejecutados desde una línea de comando."

#: ../Doc/howto/logging-cookbook.rst:2759
msgid "Buffering logging messages and outputting them conditionally"
msgstr "Almacenamiento en búfer de mensajes de logging y su salida condicional"

#: ../Doc/howto/logging-cookbook.rst:2761
msgid ""
"There might be situations where you want to log messages in a temporary area "
"and only output them if a certain condition occurs. For example, you may "
"want to start logging debug events in a function, and if the function "
"completes without errors, you don't want to clutter the log with the "
"collected debug information, but if there is an error, you want all the "
"debug information to be output as well as the error."
msgstr ""
"Puede haber situaciones en las que desee registrar mensajes en un área "
"temporal y solo mostrarlos si se produce una determinada condición. Por "
"ejemplo, es posible que desee comenzar a registrar eventos de depuración en "
"una función, y si la función se completa sin errores, no desea saturar el "
"log con la información de depuración recopilada; pero si hay un error, desea "
"toda la información de depuración información así como el error."

#: ../Doc/howto/logging-cookbook.rst:2768
msgid ""
"Here is an example which shows how you could do this using a decorator for "
"your functions where you want logging to behave this way. It makes use of "
"the :class:`logging.handlers.MemoryHandler`, which allows buffering of "
"logged events until some condition occurs, at which point the buffered "
"events are ``flushed`` - passed to another handler (the ``target`` handler) "
"for processing. By default, the ``MemoryHandler`` flushed when its buffer "
"gets filled up or an event whose level is greater than or equal to a "
"specified threshold is seen. You can use this recipe with a more specialised "
"subclass of ``MemoryHandler`` if you want custom flushing behavior."
msgstr ""
"Aquí hay un ejemplo que muestra cómo puede hacer esto usando un decorador "
"para sus funciones donde desea que el logging se comporte de esta manera. "
"Hace uso de :class:`logging.handlers.MemoryHandler`, que permite el "
"almacenamiento en búfer de eventos registrados hasta que se produzca alguna "
"condición, momento en el que los eventos almacenados en búfer se ``flushed`` "
"y se pasan a otro gestor (el gestor ``target``) para su procesamiento. De "
"forma predeterminada, el ``MemoryHandler`` se vacía cuando su búfer se llena "
"o se ve un evento cuyo nivel es mayor o igual a un umbral especificado. "
"Puede usar esta receta con una subclase más especializada de "
"``MemoryHandler`` si desea un comportamiento de descarga personalizado."

#: ../Doc/howto/logging-cookbook.rst:2778
msgid ""
"The example script has a simple function, ``foo``, which just cycles through "
"all the logging levels, writing to ``sys.stderr`` to say what level it's "
"about to log at, and then actually logging a message at that level. You can "
"pass a parameter to ``foo`` which, if true, will log at ERROR and CRITICAL "
"levels - otherwise, it only logs at DEBUG, INFO and WARNING levels."
msgstr ""
"El script de ejemplo tiene una función simple, ``foo``, que recorre todos "
"los niveles de logging, escribiendo en ``sys.stderr`` para decir en qué "
"nivel está a punto de *loguear* y luego registrar un mensaje en ese nivel. "
"Puede pasar un parámetro a ``foo`` que, si es verdadero, se registrará en "
"los niveles ERROR y CRITICAL; de lo contrario, solo registrará en los "
"niveles DEBUG, INFO y WARNING."

#: ../Doc/howto/logging-cookbook.rst:2784
msgid ""
"The script just arranges to decorate ``foo`` with a decorator which will do "
"the conditional logging that's required. The decorator takes a logger as a "
"parameter and attaches a memory handler for the duration of the call to the "
"decorated function. The decorator can be additionally parameterised using a "
"target handler, a level at which flushing should occur, and a capacity for "
"the buffer (number of records buffered). These default to a :class:`~logging."
"StreamHandler` which writes to ``sys.stderr``, ``logging.ERROR`` and ``100`` "
"respectively."
msgstr ""
"El script simplemente dispone decorar ``foo`` con un decorador que hará el "
"logging condicional que se requiere. El decorador toma un registrador como "
"parámetro y adjunta un gestor de memoria durante la duración de la llamada a "
"la función decorada. El decorador se puede parametrizar adicionalmente "
"utilizando un gestor *target*, un nivel en el que debe producirse el vaciado "
"y una capacidad para el búfer (número de registros almacenados en búfer). "
"Estos están predeterminados a :class:`~logging.StreamHandler` que escribe en "
"``sys.stderr``, ``logging.ERROR`` y ``100`` respectivamente."

#: ../Doc/howto/logging-cookbook.rst:2792
msgid "Here's the script::"
msgstr "Aquí está el script::"

#: ../Doc/howto/logging-cookbook.rst:2855
msgid "When this script is run, the following output should be observed:"
msgstr ""
"Cuando se ejecuta este script, se debe observar el siguiente resultado::"

#: ../Doc/howto/logging-cookbook.rst:2885
msgid ""
"As you can see, actual logging output only occurs when an event is logged "
"whose severity is ERROR or greater, but in that case, any previous events at "
"lower severities are also logged."
msgstr ""
"Como puede ver, la salida real de logging solo ocurre cuando se registra un "
"evento cuya gravedad es ERROR o mayor, pero en ese caso, también se registra "
"cualquier evento anterior con una gravedad menor."

#: ../Doc/howto/logging-cookbook.rst:2889
msgid "You can of course use the conventional means of decoration::"
msgstr "Por supuesto, puede utilizar las formas de decoración convencionales::"

#: ../Doc/howto/logging-cookbook.rst:2899
msgid "Sending logging messages to email, with buffering"
msgstr ""
"Enviando mensajes de logging al correo electrónico, con almacenamiento en "
"búfer"

#: ../Doc/howto/logging-cookbook.rst:2901
msgid ""
"To illustrate how you can send log messages via email, so that a set number "
"of messages are sent per email, you can subclass :class:`~logging.handlers."
"BufferingHandler`. In the following  example, which you can adapt to suit "
"your specific needs, a simple test harness is provided which allows you to "
"run the script with command line arguments specifying what you typically "
"need to send things via SMTP. (Run the downloaded script with the ``-h`` "
"argument to see the required and optional arguments.)"
msgstr ""
"Para ilustrar cómo puede enviar mensajes de logging por correo electrónico, "
"de modo que se envíe un número determinado de mensajes, puede usar la "
"subclase :class:`~logging.handlers.BufferingHandler`. En el siguiente "
"ejemplo, que puedes adaptar a tus necesidades específicas, se proporciona un "
"sencillo arnés de pruebas que permite ejecutar el script con argumentos de "
"línea de comandos especificando lo que normalmente necesitas para enviar "
"cosas por SMTP. (Ejecute el script descargado con el argumento ``-h`` para "
"ver los argumentos necesarios y opcionales)."

#: ../Doc/howto/logging-cookbook.rst:2973
msgid ""
"If you run this script and your SMTP server is correctly set up, you should "
"find that it sends eleven emails to the addressee you specify. The first ten "
"emails will each have ten log messages, and the eleventh will have two "
"messages. That makes up 102 messages as specified in the script."
msgstr ""
"Si ejecuta este script y su servidor SMTP está correctamente configurado, "
"debería ver que envía once correos electrónicos al destinatario que usted "
"especifique. Los primeros diez correos electrónicos tendrán cada uno diez "
"mensajes de log, y el undécimo tendrá dos mensajes. Eso hace 102 mensajes "
"como se especifica en el script."

#: ../Doc/howto/logging-cookbook.rst:2981
msgid "Formatting times using UTC (GMT) via configuration"
msgstr "Formateo de horas usando UTC (GMT) a través de la configuración"

#: ../Doc/howto/logging-cookbook.rst:2983
msgid ""
"Sometimes you want to format times using UTC, which can be done using a "
"class such as ``UTCFormatter``, shown below::"
msgstr ""
"A veces desea formatear las horas usando UTC, lo que se puede hacer usando "
"una clase como ``UTCFormatter``, como se muestra a continuación::"

#: ../Doc/howto/logging-cookbook.rst:2992
msgid ""
"and you can then use the ``UTCFormatter`` in your code instead of :class:"
"`~logging.Formatter`. If you want to do that via configuration, you can use "
"the :func:`~logging.config.dictConfig` API with an approach illustrated by "
"the following complete example::"
msgstr ""
"y luego puede usar el ``UTCFormatter`` en su código en lugar de :class:"
"`~logging.Formatter`. Si desea hacer eso a través de la configuración, puede "
"usar la API :func:`~logging.config.dictConfig` con un enfoque ilustrado por "
"el siguiente ejemplo completo::"

#: ../Doc/howto/logging-cookbook.rst:3035
msgid "When this script is run, it should print something like:"
msgstr "Cuando se ejecuta este script, debería imprimir algo como:"

#: ../Doc/howto/logging-cookbook.rst:3042
msgid ""
"showing how the time is formatted both as local time and UTC, one for each "
"handler."
msgstr ""
"mostrando cómo se formatea la hora como hora local y UTC, una para cada "
"gestor."

#: ../Doc/howto/logging-cookbook.rst:3049
msgid "Using a context manager for selective logging"
msgstr "Usar un administrador de contexto para logging selectivo"

#: ../Doc/howto/logging-cookbook.rst:3051
msgid ""
"There are times when it would be useful to temporarily change the logging "
"configuration and revert it back after doing something. For this, a context "
"manager is the most obvious way of saving and restoring the logging context. "
"Here is a simple example of such a context manager, which allows you to "
"optionally change the logging level and add a logging handler purely in the "
"scope of the context manager::"
msgstr ""
"Hay ocasiones en las que sería útil cambiar temporalmente la configuración "
"de logging y revertir esto después de hacer algo. Para ello, un "
"administrador de contexto es la forma más obvia de guardar y restaurar el "
"contexto de logging. Aquí hay un ejemplo simple de un administrador de "
"contexto de este tipo, que le permite cambiar opcionalmente el nivel de "
"logging y agregar un gestor de logging exclusivamente en el alcance del "
"administrador de contexto::"

#: ../Doc/howto/logging-cookbook.rst:3084
msgid ""
"If you specify a level value, the logger's level is set to that value in the "
"scope of the with block covered by the context manager. If you specify a "
"handler, it is added to the logger on entry to the block and removed on exit "
"from the block. You can also ask the manager to close the handler for you on "
"block exit - you could do this if you don't need the handler any more."
msgstr ""
"Si especifica un valor de nivel, el nivel del registrador se establece en "
"ese valor en el alcance del bloque *with* cubierto por el administrador de "
"contexto. Si especifica un gestor, se agrega al registrador al entrar al "
"bloque y se elimina al salir del bloque. También puede pedirle al "
"administrador que cierre el gestor por usted al salir del bloque si ya no lo "
"necesita."

#: ../Doc/howto/logging-cookbook.rst:3090
msgid ""
"To illustrate how it works, we can add the following block of code to the "
"above::"
msgstr ""
"Para ilustrar cómo funciona, podemos agregar el siguiente bloque de código "
"al anterior::"

#: ../Doc/howto/logging-cookbook.rst:3108
msgid ""
"We initially set the logger's level to ``INFO``, so message #1 appears and "
"message #2 doesn't. We then change the level to ``DEBUG`` temporarily in the "
"following ``with`` block, and so message #3 appears. After the block exits, "
"the logger's level is restored to ``INFO`` and so message #4 doesn't appear. "
"In the next ``with`` block, we set the level to ``DEBUG`` again but also add "
"a handler writing to ``sys.stdout``. Thus, message #5 appears twice on the "
"console (once via ``stderr`` and once via ``stdout``). After the ``with`` "
"statement's completion, the status is as it was before so message #6 appears "
"(like message #1) whereas message #7 doesn't (just like message #2)."
msgstr ""
"Inicialmente configuramos el nivel del registrador en ``INFO``, por lo que "
"aparece el mensaje #1 y el mensaje #2 no. Luego cambiamos el nivel a "
"``DEBUG`` temporalmente en el siguiente bloque ``with``, y aparece el "
"mensaje #3. Una vez que se sale del bloque, el nivel del registrador se "
"restaura a ``INFO`` y, por lo tanto, el mensaje #4 no aparece. En el "
"siguiente bloque ``with``, configuramos el nivel en ``DEBUG`` nuevamente, "
"pero también agregamos un gestor que escribe en ``sys.stdout``. Por lo "
"tanto, el mensaje #5 aparece dos veces en la consola (una vez a través de "
"``stderr`` y una vez a través de ``stdout``). Después de la finalización de "
"la declaración ``with``, se vuelve al estado anterior, por lo que aparece el "
"mensaje #6 (como el mensaje #1) mientras que el mensaje #7 no (como el "
"mensaje #2)."

#: ../Doc/howto/logging-cookbook.rst:3118
msgid "If we run the resulting script, the result is as follows:"
msgstr "Si ejecutamos el script resultante, el resultado es el siguiente:"

#: ../Doc/howto/logging-cookbook.rst:3129
msgid ""
"If we run it again, but pipe ``stderr`` to ``/dev/null``, we see the "
"following, which is the only message written to ``stdout``:"
msgstr ""
"Si lo ejecutamos de nuevo, pero dirigimos ``stderr`` a ``/dev/null``, vemos "
"lo siguiente, que es el único mensaje escrito en ``stdout``:"

#: ../Doc/howto/logging-cookbook.rst:3137
msgid "Once again, but piping ``stdout`` to ``/dev/null``, we get:"
msgstr "Una vez más, pero canalizando ``stdout`` a ``/dev/null``, obtenemos:"

#: ../Doc/howto/logging-cookbook.rst:3147
msgid ""
"In this case, the message #5 printed to ``stdout`` doesn't appear, as "
"expected."
msgstr ""
"En este caso, el mensaje #5 impreso en ``stdout`` no aparece, como se "
"esperaba."

#: ../Doc/howto/logging-cookbook.rst:3149
msgid ""
"Of course, the approach described here can be generalised, for example to "
"attach logging filters temporarily. Note that the above code works in Python "
"2 as well as Python 3."
msgstr ""
"Por supuesto, el enfoque descrito aquí puede generalizarse, por ejemplo, "
"para adjuntar filtros de logging temporalmente. Tenga en cuenta que el "
"código anterior funciona tanto en Python 2 como en Python 3."

#: ../Doc/howto/logging-cookbook.rst:3157
msgid "A CLI application starter template"
msgstr "Una plantilla de inicio de aplicación CLI"

#: ../Doc/howto/logging-cookbook.rst:3159
msgid "Here's an example which shows how you can:"
msgstr "Aquí hay un ejemplo que muestra cómo puede:"

#: ../Doc/howto/logging-cookbook.rst:3161
msgid "Use a logging level based on command-line arguments"
msgstr ""
"Utilizar un nivel de logging basado en argumentos de la línea de comandos"

#: ../Doc/howto/logging-cookbook.rst:3162
msgid ""
"Dispatch to multiple subcommands in separate files, all logging at the same "
"level in a consistent way"
msgstr ""
"Enviar a varios subcomandos en archivos separados, todos registrando en el "
"mismo nivel de forma coherente"

#: ../Doc/howto/logging-cookbook.rst:3164
msgid "Make use of simple, minimal configuration"
msgstr "Utilizar una configuración mínima y sencilla"

#: ../Doc/howto/logging-cookbook.rst:3166
msgid ""
"Suppose we have a command-line application whose job is to stop, start or "
"restart some services. This could be organised for the purposes of "
"illustration as a file ``app.py`` that is the main script for the "
"application, with individual commands implemented in ``start.py``, ``stop."
"py`` and ``restart.py``. Suppose further that we want to control the "
"verbosity of the application via a command-line argument, defaulting to "
"``logging.INFO``. Here's one way that ``app.py`` could be written::"
msgstr ""
"Supongamos que tenemos una aplicación de línea de comandos cuyo trabajo es "
"detener, iniciar o reiniciar algunos servicios. Esto podría organizarse con "
"fines ilustrativos como un archivo ``app.py`` que es el script principal de "
"la aplicación, con comandos individuales implementados en ``start.py``, "
"``stop.py`` y ``restart.py``. Supongamos además que queremos controlar la "
"verbosidad de la aplicación a través de un argumento de línea de comandos, "
"por defecto en ``logging.INFO``. Aquí hay una forma en que se podría "
"escribir ``app.py``::"

#: ../Doc/howto/logging-cookbook.rst:3215
msgid ""
"And the ``start``, ``stop`` and ``restart`` commands can be implemented in "
"separate modules, like so for starting::"
msgstr ""
"Y los comandos ``start``, ``stop`` y ``reiniciar`` se pueden implementar en "
"módulos separados, como para iniciar::"

#: ../Doc/howto/logging-cookbook.rst:3228
msgid "and thus for stopping::"
msgstr "y así para detener::"

#: ../Doc/howto/logging-cookbook.rst:3249
msgid "and similarly for restarting::"
msgstr "y de manera similar para reiniciar::"

#: ../Doc/howto/logging-cookbook.rst:3270
msgid ""
"If we run this application with the default log level, we get output like "
"this:"
msgstr ""
"Si ejecutamos esta aplicación con el nivel de log predeterminado, obtenemos "
"un resultado como este:"

#: ../Doc/howto/logging-cookbook.rst:3283
msgid ""
"The first word is the logging level, and the second word is the module or "
"package name of the place where the event was logged."
msgstr ""
"La primera palabra es el nivel de logging y la segunda palabra es el nombre "
"del módulo o paquete del lugar donde se registró el evento."

#: ../Doc/howto/logging-cookbook.rst:3286
msgid ""
"If we change the logging level, then we can change the information sent to "
"the log. For example, if we want more information:"
msgstr ""
"Si cambiamos el nivel de logging, podemos cambiar la información enviada al "
"log. Por ejemplo, si queremos más información:"

#: ../Doc/howto/logging-cookbook.rst:3303
msgid "And if we want less:"
msgstr "Y si queremos menos:"

#: ../Doc/howto/logging-cookbook.rst:3311
msgid ""
"In this case, the commands don't print anything to the console, since "
"nothing at ``WARNING`` level or above is logged by them."
msgstr ""
"En este caso, los comandos no imprimen nada en la consola, ya que no "
"registran nada en el nivel de ``WARNING`` o superior."

#: ../Doc/howto/logging-cookbook.rst:3317
msgid "A Qt GUI for logging"
msgstr "Una GUI de Qt para logging"

#: ../Doc/howto/logging-cookbook.rst:3319
msgid ""
"A question that comes up from time to time is about how to log to a GUI "
"application. The `Qt <https://www.qt.io/>`_ framework is a popular cross-"
"platform UI framework with Python bindings using `PySide2 <https://pypi.org/"
"project/PySide2/>`_ or `PyQt5 <https://pypi.org/project/PyQt5/>`_ libraries."
msgstr ""
"Una pregunta que surge de vez en cuando es sobre cómo *loggear* en una "
"aplicación GUI. El *framework* `Qt <https://www.qt.io/>`_ es un *framework* "
"popular multiplataforma con bindings de Python que usan `PySide2 <https://"
"pypi.org/project/PySide2/>`_ o librerías `PyQt5 <https://pypi.org/project/"
"PyQt5/>`_."

#: ../Doc/howto/logging-cookbook.rst:3325
msgid ""
"The following example shows how to log to a Qt GUI. This introduces a simple "
"``QtHandler`` class which takes a callable, which should be a slot in the "
"main thread that does GUI updates. A worker thread is also created to show "
"how you can log to the GUI from both the UI itself (via a button for manual "
"logging) as well as a worker thread doing work in the background (here, just "
"logging messages at random levels with random short delays in between)."
msgstr ""
"El siguiente ejemplo muestra cómo iniciar sesión en una GUI de Qt. Esto "
"introduce una clase simple ``QtHandler`` que toma un invocable, que debería "
"ser un slot en el hilo principal que realiza actualizaciones de la GUI. "
"También se crea un hilo de trabajo para mostrar cómo puede iniciar sesión en "
"la GUI tanto desde la propia interfaz de usuario (a través de un botón para "
"el logging manual) como desde un hilo de trabajo que trabaja en segundo "
"plano (aquí, simplemente registrando mensajes en niveles aleatorios con "
"aleatorio breves retrasos intermedios)."

#: ../Doc/howto/logging-cookbook.rst:3332
msgid ""
"The worker thread is implemented using Qt's ``QThread`` class rather than "
"the :mod:`threading` module, as there are circumstances where one has to use "
"``QThread``, which offers better integration with other ``Qt`` components."
msgstr ""
"El hilo *worker* se implementa usando la clase ``QThread`` de Qt en lugar "
"del módulo :mod:`threading`, ya que hay circunstancias en las que uno tiene "
"que usar ``QThread``, que ofrece una mejor integración con otros componentes "
"``Qt``."

#: ../Doc/howto/logging-cookbook.rst:3336
msgid ""
"The code should work with recent releases of either ``PySide2`` or "
"``PyQt5``. You should be able to adapt the approach to earlier versions of "
"Qt. Please refer to the comments in the code snippet for more detailed "
"information."
msgstr ""
"El código debería funcionar con versiones recientes de ``PySide2`` o "
"``PyQt5``. Debería poder adaptar el enfoque a versiones anteriores de Qt. "
"Consulte los comentarios en el fragmento de código para obtener información "
"más detallada."

#: ../Doc/howto/logging-cookbook.rst:3550
msgid "Logging to syslog with RFC5424 support"
msgstr "Logging en syslog con soporte RFC5424"

#: ../Doc/howto/logging-cookbook.rst:3552
msgid ""
"Although :rfc:`5424` dates from 2009, most syslog servers are configured by "
"detault to use the older :rfc:`3164`, which hails from 2001. When "
"``logging`` was added to Python in 2003, it supported the earlier (and only "
"existing) protocol at the time. Since RFC5424 came out, as there has not "
"been widespread deployment of it in syslog servers, the :class:`~logging."
"handlers.SysLogHandler` functionality has not been updated."
msgstr ""
"Aunque :rfc:`5424` data de 2009, la mayoría de los servidores de syslog "
"están configurados por defecto para utilizar el antiguo :rfc:`3164`, que "
"data de 2001. Cuando se añadió ``logging`` a Python en 2003, soportaba el "
"anterior (y único existente) protocolo en ese momento. Desde que salió el "
"RFC5424, como no ha habido un despliegue generalizado del mismo en los "
"servidores de syslog, la funcionalidad :class:`~logging.handlers."
"SysLogHandler` no ha sido actualizada."

#: ../Doc/howto/logging-cookbook.rst:3559
msgid ""
"RFC 5424 contains some useful features such as support for structured data, "
"and if you need to be able to log to a syslog server with support for it, "
"you can do so with a subclassed handler which looks something like this::"
msgstr ""
"El RFC 5424 contiene algunas características útiles como el soporte para "
"datos estructurados, y si necesitas poder registrar en un servidor syslog "
"con soporte para ello, puedes hacerlo con una subclase *handler* que se "
"parezca a esto::"

#: ../Doc/howto/logging-cookbook.rst:3625
msgid ""
"You'll need to be familiar with RFC 5424 to fully understand the above code, "
"and it may be that you have slightly different needs (e.g. for how you pass "
"structural data to the log). Nevertheless, the above should be adaptable to "
"your speciric needs. With the above handler, you'd pass structured data "
"using something like this::"
msgstr ""
"Tendrá que estar familiarizado con el RFC 5424 para entender completamente "
"el código anterior, y puede ser que tenga necesidades ligeramente diferentes "
"(por ejemplo, para la forma de pasar los datos estructurales al log). No "
"obstante, lo anterior debería poder adaptarse a sus necesidades específicas. "
"Con el gestor anterior, usted pasaría datos estructurados usando algo como "
"esto::"

#: ../Doc/howto/logging-cookbook.rst:3639
msgid "How to treat a logger like an output stream"
msgstr "Cómo tratar un logger como una salida stream"

#: ../Doc/howto/logging-cookbook.rst:3641
msgid ""
"Sometimes, you need to interface to a third-party API which expects a file-"
"like object to write to, but you want to direct the API's output to a "
"logger. You can do this using a class which wraps a logger with a file-like "
"API. Here's a short script illustrating such a class:"
msgstr ""
"A veces, necesitas interactuar con una API de terceros que espera un objeto "
"tipo archivo para escribir, pero quieres dirigir la salida de la API a un "
"logger. Puedes hacer esto usando una clase que envuelva un logger con una "
"API tipo archivo. Aquí hay un pequeño script que ilustra tal clase:"

#: ../Doc/howto/logging-cookbook.rst:3681
msgid "When this script is run, it prints"
msgstr "Cuando se ejecuta este script, se imprime"

#: ../Doc/howto/logging-cookbook.rst:3688
msgid ""
"You could also use ``LoggerWriter`` to redirect ``sys.stdout`` and ``sys."
"stderr`` by doing something like this:"
msgstr ""
"También puedes usar ``LoggerWriter`` para redirigir ``sys.stdout`` y ``sys."
"stderr`` haciendo algo así:"

#: ../Doc/howto/logging-cookbook.rst:3698
msgid ""
"You should do this *after* configuring logging for your needs. In the above "
"example, the :func:`~logging.basicConfig` call does this (using the ``sys."
"stderr`` value *before* it is overwritten by a ``LoggerWriter`` instance). "
"Then, you'd get this kind of result:"
msgstr ""
"Debería hacer esto *después* de configurar logging para sus necesidades. En "
"el ejemplo anterior, la llamada :func:`~logging.basicConfig` hace esto "
"(utilizando el valor de ``sys.stderr`` *antes* de que sea sobrescrito por "
"una instancia de ``LoggerWriter``). Entonces, obtendrías este tipo de "
"resultado:"

#: ../Doc/howto/logging-cookbook.rst:3711
msgid ""
"Of course, the examples above show output according to the format used by :"
"func:`~logging.basicConfig`, but you can use a different formatter when you "
"configure logging."
msgstr ""
"Por supuesto, los ejemplos anteriores muestran la salida según el formato "
"utilizado por :func:`~logging.basicConfig`, pero puede utilizar un "
"formateador diferente cuando configure logging."

#: ../Doc/howto/logging-cookbook.rst:3715
msgid ""
"Note that with the above scheme, you are somewhat at the mercy of buffering "
"and the sequence of write calls which you are intercepting. For example, "
"with the definition of ``LoggerWriter`` above, if you have the snippet"
msgstr ""
"Ten en cuenta que con el esquema anterior, estás un poco a merced del "
"buffering y de la secuencia de llamadas de escritura que estás "
"interceptando. Por ejemplo, con la definición de ``LoggerWriter`` anterior, "
"si tienes el fragmento"

#: ../Doc/howto/logging-cookbook.rst:3724
msgid "then running the script results in"
msgstr "entonces la ejecución del script da como resultado"

#: ../Doc/howto/logging-cookbook.rst:3742
msgid ""
"As you can see, this output isn't ideal. That's because the underlying code "
"which writes to ``sys.stderr`` makes mutiple writes, each of which results "
"in a separate logged line (for example, the last three lines above). To get "
"around this problem, you need to buffer things and only output log lines "
"when newlines are seen. Let's use a slghtly better implementation of "
"``LoggerWriter``:"
msgstr ""
"Como puedes ver, esta salida no es ideal. Esto se debe a que el código "
"subyacente que escribe en ``sys.stderr`` hace múltiples escrituras, cada una "
"de las cuales resulta en una línea de registro separada (por ejemplo, las "
"tres últimas líneas de arriba). Para evitar este problema, es necesario "
"almacenar las cosas y sólo emitir líneas de logging cuando se vean nuevas "
"líneas. Utilicemos una implementación ligeramente mejor de ``LoggerWriter``:"

#: ../Doc/howto/logging-cookbook.rst:3767
msgid ""
"This just buffers up stuff until a newline is seen, and then logs complete "
"lines. With this approach, you get better output:"
msgstr ""
"Esto sólo almacena cosas hasta que se ve una nueva línea, y luego registra "
"las líneas completas. Con este enfoque, se obtiene una mejor salida:"

#: ../Doc/howto/logging-cookbook.rst:3783
msgid "Patterns to avoid"
msgstr "Patrones para evitar"

#: ../Doc/howto/logging-cookbook.rst:3785
msgid ""
"Although the preceding sections have described ways of doing things you "
"might need to do or deal with, it is worth mentioning some usage patterns "
"which are *unhelpful*, and which should therefore be avoided in most cases. "
"The following sections are in no particular order."
msgstr ""
"Aunque las secciones anteriores han descrito formas de hacer las cosas que "
"podría necesitar hacer o con las que tratar, vale la pena mencionar algunos "
"patrones de uso que son *inútiles* y que, por lo tanto, deben evitarse en la "
"mayoría de los casos. Las siguientes secciones no están en ningún orden en "
"particular."

#: ../Doc/howto/logging-cookbook.rst:3791
msgid "Opening the same log file multiple times"
msgstr "Abrir el mismo archivo de registro varias veces"

#: ../Doc/howto/logging-cookbook.rst:3793
msgid ""
"On Windows, you will generally not be able to open the same file multiple "
"times as this will lead to a \"file is in use by another process\" error. "
"However, on POSIX platforms you'll not get any errors if you open the same "
"file multiple times. This could be done accidentally, for example by:"
msgstr ""
"En Windows, por lo general, no podrá abrir el mismo archivo varias veces, ya "
"que esto lanzará un error de \"otro proceso está usando el archivo\". Sin "
"embargo, en las plataformas POSIX no obtendrá ningún error si abre el mismo "
"archivo varias veces. Esto podría hacerse accidentalmente, por ejemplo:"

#: ../Doc/howto/logging-cookbook.rst:3798
msgid ""
"Adding a file handler more than once which references the same file (e.g. by "
"a copy/paste/forget-to-change error)."
msgstr ""
"Agregar un controlador de archivos más de una vez que hace referencia al "
"mismo archivo (por ejemplo, mediante un error de copiar/pegar/olvidar-"
"cambiar)."

#: ../Doc/howto/logging-cookbook.rst:3801
msgid ""
"Opening two files that look different, as they have different names, but are "
"the same because one is a symbolic link to the other."
msgstr ""
"Abrir dos archivos que se ven diferentes, ya que tienen diferentes nombres, "
"pero son iguales porque uno es un enlace simbólico al otro."

#: ../Doc/howto/logging-cookbook.rst:3804
msgid ""
"Forking a process, following which both parent and child have a reference to "
"the same file. This might be through use of the :mod:`multiprocessing` "
"module, for example."
msgstr ""
"Bifurcar un proceso, después del cual tanto el padre como el hijo tienen una "
"referencia al mismo archivo. Esto podría ser mediante el uso del módulo :mod:"
"`multiprocessing`, por ejemplo."

#: ../Doc/howto/logging-cookbook.rst:3808
msgid ""
"Opening a file multiple times might *appear* to work most of the time, but "
"can lead to a number of problems in practice:"
msgstr ""
"Abrir un archivo varias veces puede *parecer* que funciona la mayor parte "
"del tiempo, pero puede dar lugar a una serie de problemas en la práctica:"

#: ../Doc/howto/logging-cookbook.rst:3811
msgid ""
"Logging output can be garbled because multiple threads or processes try to "
"write to the same file. Although logging guards against concurrent use of "
"the same handler instance by multiple threads, there is no such protection "
"if concurrent writes are attempted by two different threads using two "
"different handler instances which happen to point to the same file."
msgstr ""
"La salida del registro se puede distorsionar porque varios subprocesos o "
"procesos intentan escribir en el mismo archivo. Aunque el registro se "
"protege de el uso simultáneo de la misma instancia de controlador por varios "
"subprocesos, no existe tal protección si dos subprocesos diferentes intentan "
"escrituras simultáneas utilizando dos instancias de controlador diferentes "
"que apunten al mismo archivo."

#: ../Doc/howto/logging-cookbook.rst:3817
msgid ""
"An attempt to delete a file (e.g. during file rotation) silently fails, "
"because there is another reference pointing to it. This can lead to "
"confusion and wasted debugging time - log entries end up in unexpected "
"places, or are lost altogether. Or a file that was supposed to be moved "
"remains in place, and grows in size unexpectedly despite size-based rotation "
"being supposedly in place."
msgstr ""
"Un intento de eliminar un archivo (por ejemplo, durante la rotación de "
"archivos) falla silenciosamente, porque hay otra referencia que apunta a él. "
"Esto puede generar confusión y una pérdida de tiempo de depuración: las "
"entradas del registro terminan en lugares inesperados o se pierden por "
"completo. O un archivo que debía ser movido permanece en su lugar, y crece "
"en tamaño inesperadamente a pesar de que la rotación basada en el tamaño "
"está supuestamente en su lugar."

#: ../Doc/howto/logging-cookbook.rst:3824
msgid ""
"Use the techniques outlined in :ref:`multiple-processes` to circumvent such "
"issues."
msgstr ""
"Utilice las técnicas descritas en :ref:`multiple-processes` para evitar "
"estos problemas."

#: ../Doc/howto/logging-cookbook.rst:3828
msgid "Using loggers as attributes in a class or passing them as parameters"
msgstr ""
"Usar registradores como atributos en una clase o pasarlos como parámetros"

#: ../Doc/howto/logging-cookbook.rst:3830
msgid ""
"While there might be unusual cases where you'll need to do this, in general "
"there is no point because loggers are singletons. Code can always access a "
"given logger instance by name using ``logging.getLogger(name)``, so passing "
"instances around and holding them as instance attributes is pointless. Note "
"that in other languages such as Java and C#, loggers are often static class "
"attributes. However, this pattern doesn't make sense in Python, where the "
"module (and not the class) is the unit of software decomposition."
msgstr ""
"Si bien puede haber casos inusuales en los que deba hacer esto, en general "
"no tiene sentido porque los registradores son singletons. El código siempre "
"puede acceder a una instancia de registrador dada por su nombre usando "
"``logging.getLogger(name)``, por lo que pasar instancias y mantenerlas como "
"atributos de instancia no tiene sentido. Tenga en cuenta que en otros "
"lenguajes como Java y C#, los registradores suelen ser atributos de clase "
"estáticos. Sin embargo, este patrón no tiene sentido en Python, donde el "
"módulo (y no la clase) es la unidad de descomposición del software."

#: ../Doc/howto/logging-cookbook.rst:3839
msgid ""
"Adding handlers other than :class:`NullHandler` to a logger in a library"
msgstr ""
"Agregar controladores distintos de :class:`NullHandler` a un registrador en "
"una biblioteca"

#: ../Doc/howto/logging-cookbook.rst:3841
msgid ""
"Configuring logging by adding handlers, formatters and filters is the "
"responsibility of the application developer, not the library developer. If "
"you are maintaining a library, ensure that you don't add handlers to any of "
"your loggers other than a :class:`~logging.NullHandler` instance."
msgstr ""
"La configuración del registro agregando controladores, formateadores y "
"filtros es responsabilidad del desarrollador de la aplicación, no del "
"desarrollador de la biblioteca. Si mantiene una biblioteca, asegúrese de no "
"agregar controladores a ninguno de sus registradores que no sean una "
"instancia :class:`~logging.NullHandler`."

#: ../Doc/howto/logging-cookbook.rst:3847
msgid "Creating a lot of loggers"
msgstr "Crear muchos registradores (*loggers*)"

#: ../Doc/howto/logging-cookbook.rst:3849
msgid ""
"Loggers are singletons that are never freed during a script execution, and "
"so creating lots of loggers will use up memory which can't then be freed. "
"Rather than create a logger per e.g. file processed or network connection "
"made, use the :ref:`existing mechanisms <context-info>` for passing "
"contextual information into your logs and restrict the loggers created to "
"those describing areas within your application (generally modules, but "
"occasionally slightly more fine-grained than that)."
msgstr ""
"Los registradores son singletons que nunca se liberan durante la ejecución "
"de un script, por lo que la creación de muchos registradores consumirá "
"memoria que luego no se puede liberar. En lugar de crear un registrador por "
"ej. archivo procesado o conexión de red realizada, use los :ref:`mecanismos "
"existentes <context-info>` para pasar información contextual a sus registros "
"y restringir los registradores creados a aquellos que describen áreas dentro "
"de su aplicación (generalmente módulos, pero ocasionalmente un poco más "
"detallado que eso)."

#: ../Doc/howto/logging-cookbook.rst:3860
msgid "Other resources"
msgstr "Otros recursos"

#: ../Doc/howto/logging-cookbook.rst:3873
msgid ":ref:`Basic Tutorial <logging-basic-tutorial>`"
msgstr ":ref:`Tutorial Básico <logging-basic-tutorial>`"

#: ../Doc/howto/logging-cookbook.rst:3875
msgid ":ref:`Advanced Tutorial <logging-advanced-tutorial>`"
msgstr ":ref:`Tutorial Avanzado <logging-advanced-tutorial>`"