CHANGELOG.rst

Unreleased

• Fix possible RuntimeError when removing all handlers with logger.remove() due to thread-safety issue (#1183, thanks @jeremyk).
• Improve performance of datetime formatting while logging messages (#1201, thanks @trim21).
• Reduce startup time in the presence of installed but unused IPython third-party library (#1001, thanks @zakstucke).

0.7.2 (2023-09-11)

• Add support for formatting of ExceptionGroup errors (#805).
• Fix possible RuntimeError when using multiprocessing.set_start_method() after importing the logger (#974).
• Fix formatting of possible __notes__ attached to an Exception (#980).

0.7.1 (2023-09-04)

• Add a new context optional argument to logger.add() specifying multiprocessing context (like "spawn" or "fork") to be used internally instead of the default one (#851).
• Add support for true colors on Windows using ANSI/VT console when available (#934, thanks @tunaflsh).
• Fix possible deadlock when calling logger.complete() with concurrent logging of an asynchronous sink (#906).
• Fix file possibly rotating too early or too late when re-starting an application around midnight (#894).
• Fix inverted "<hide>" and "<strike>" color tags (#943, thanks @tunaflsh).
• Fix possible untraceable errors raised when logging non-unpicklable Exception instances while using enqueue=True (#329).
• Fix possible errors raised when logging non-picklable Exception instances while using enqueue=True (#342, thanks @ncoudene).
• Fix missing seconds and microseconds when formatting timezone offset that requires such accuracy (#961).
• Raise ValueError if an attempt to use nanosecond precision for time formatting is detected (#855).

0.7.0 (2023-04-10)

• Update InterceptHandler recipe to make it compatible with Python 3.11 (#654).
• Add a new watch optional argument to file sinks in order to automatically re-create possibly deleted or changed file (#471).
• Make patch() calls cumulative instead of overriding the possibly existing patching function (#462).
• Make sinks added with enqueue=True and catch=False still process logged messages in case of internal exception (#833).
• Avoid possible deadlocks caused by re-using the logger inside a sink, a signal handler or a __del__ method. Since the logger is not re-entrant, such misuse will be detected and will now generate a RuntimeError (#712, thanks @jacksmith15).
• Fix file sink rotation using an aware datetime.time for which the timezone was ignored (#697).
• Fix logs colorization not automatically enabled for Jupyter Notebook and Google Colab (#494).
• Fix logs colorization not automatically enabled for Github Actions and others CI platforms (#604).
• Fix logger.complete() possibly hanging forever when enqueue=True and catch=False if internal thread killed due to Exception raised by sink (#647).
• Fix incompatibility with freezegun library used to simulate time (#600).
• Raise exception if logger.catch() is used to wrap a class instead of a function to avoid unexpected behavior (#623).

0.6.0 (2022-01-29)

• Remove internal use of pickle.loads() to fix the (finally rejected) security vulnerability referenced as CVE-2022-0329 (#563).
• Modify coroutine sink to make it discard log messages when loop=None and no event loop is running (due to internally using asyncio.get_running_loop() in place of asyncio.get_event_loop()).
• Remove the possibility to add a coroutine sink with enqueue=True if loop=None and no event loop is running.
• Change default encoding of file sink to be utf8 instead of locale.getpreferredencoding() (#339).
• Prevent non-ascii characters to be escaped while logging JSON message with serialize=True (#575, thanks @ponponon).
• Fix flake8 errors and improve code readability (#353, thanks @AndrewYakimets).

0.5.3 (2020-09-20)

• Fix child process possibly hanging at exit while combining enqueue=True with third party library like uwsgi (#309, thanks @dstlmrk).
• Fix possible exception during formatting of non-string messages (#331).

0.5.2 (2020-09-06)

• Fix AttributeError within handlers using serialize=True when calling logger.exception() outside of the context of an exception (#296).
• Fix error while logging an exception containing a non-picklable value to a handler with enqueue=True (#298).
• Add support for async callable classes (with __call__ method) used as sinks (#294, thanks @jessekrubin).

0.5.1 (2020-06-12)

• Modify the way the extra dict is used by LogRecord in order to prevent possible KeyError with standard logging handlers (#271).
• Add a new default optional argument to logger.catch(), it should be the returned value by the decorated function in case an error occurred (#272).
• Fix ValueError when using serialize=True in combination with logger.catch() or logger.opt(record=True) due to circular reference of the record dict (#286).

0.5.0 (2020-05-17)

• Remove the possibility to modify the severity no of levels once they have been added in order to prevent surprising behavior (#209).
• Add better support for "structured logging" by automatically adding **kwargs to the extra dict besides using these arguments to format the message. This behavior can be disabled by setting the new .opt(capture=False) parameter (#2).
• Add a new onerror optional argument to logger.catch(), it should be a function which will be called when an exception occurs in order to customize error handling (#224).
• Add a new exclude optional argument to logger.catch(), is should be a type of exception to be purposefully ignored and propagated to the caller without being logged (#248).
• Modify complete() to make it callable from non-asynchronous functions, it can thus be used if enqueue=True to make sure all messages have been processed (#231).
• Fix possible deadlocks on Linux when multiprocessing.Process() collides with enqueue=True or threading (#231).
• Fix compression function not executable concurrently due to file renaming (to resolve conflicts) being performed after and not before it (#243).
• Fix the filter function listing files for retention being too restrictive, it now matches files based on the pattern "basename(.*).ext(.*)" (#229).
• Fix the impossibility to remove() a handler if an exception is raised while the sink' stop() function is called (#237).
• Fix file sink left in an unstable state if an exception occurred during retention or compression process (#238).
• Fix situation where changes made to record["message"] were unexpectedly ignored when opt(colors=True), causing "out-of-date" message to be logged due to implementation details (#221).
• Fix possible exception if a stream having an isatty() method returning True but not being compatible with colorama is used on Windows (#249).
• Fix exceptions occurring in coroutine sinks never retrieved and hence causing warnings (#227).

0.4.1 (2020-01-19)

• Deprecate the ansi parameter of .opt() in favor of colors which is a name more appropriate.
• Prevent unrelated files and directories to be incorrectly collected thus causing errors during the retention process (#195, thanks @gazpachoking).
• Strip color markups contained in record["message"] when logging with .opt(ansi=True) instead of leaving them as is (#198).
• Ignore color markups contained in *args and **kwargs when logging with .opt(ansi=True), leave them as is instead of trying to use them to colorize the message which could cause undesirable errors (#197).

0.4.0 (2019-12-02)

• Add support for coroutine functions used as sinks and add the new logger.complete() asynchronous method to await them (#171).
• Add a way to filter logs using one level per module in the form of a dict passed to the filter argument (#148).
• Add type hints to annotate the public methods using a .pyi stub file (#162).
• Add support for copy.deepcopy() of the logger allowing multiple independent loggers with separate set of handlers (#72).
• Add the possibility to convert datetime to UTC before formatting (in logs and filenames) by adding "!UTC" at the end of the time format specifier (#128).
• Add the level name as the first argument of namedtuple returned by the .level() method.
• Remove class objects from the list of supported sinks and restrict usage of **kwargs in .add() to file sink only. User is in charge of instantiating sink and wrapping additional keyword arguments if needed, before passing it to the .add() method.
• Rename the logger.configure() keyword argument patch to patcher so it better matches the signature of logger.patch().
• Fix incompatibility with multiprocessing on Windows by entirely refactoring the internal structure of the logger so it can be inherited by child processes along with added handlers (#108).
• Fix AttributeError while using a file sink on some distributions (like Alpine Linux) missing the os.getxattr and os.setxattr functions (#158, thanks @joshgordon).
• Fix values wrongly displayed for keyword arguments during exception formatting with diagnose=True (#144).
• Fix logging messages wrongly chopped off at the end while using standard logging.Handler sinks with .opt(raw=True) (#136).
• Fix potential errors during rotation if destination file exists due to large resolution clock on Windows (#179).
• Fix an error using a filter function "by name" while receiving a log with record["name"] equals to None.
• Fix incorrect record displayed while handling errors (if catch=True) occurring because of non-picklable objects (if enqueue=True).
• Prevent hypothetical ImportError if a Python installation is missing the built-in distutils module (#118).
• Raise TypeError instead of ValueError when a logger method is called with argument of invalid type.
• Raise ValueError if the built-in format() and filter() functions are respectively used as format and filter arguments of the add() method. This helps the user to understand the problem, as such a mistake can quite easily occur (#177).
• Remove inheritance of some record dict attributes to str (for "level", "file", "thread" and "process").
• Give a name to the worker thread used when enqueue=True (#174, thanks @t-mart).

0.3.2 (2019-07-21)

• Fix exception during import when executing Python with -s and -S flags causing site.USER_SITE to be missing (#114).

0.3.1 (2019-07-13)

• Fix retention and rotation issues when file sink initialized with delay=True (#113).
• Fix "sec" no longer recognized as a valid duration unit for file rotation and retention arguments.
• Ensure stack from the caller is displayed while formatting exception of a function decorated with @logger.catch when backtrace=False.
• Modify datetime used to automatically rename conflicting file when rotating (it happens if file already exists because "{time}" not presents in filename) so it's based on the file creation time rather than the current time.

0.3.0 (2019-06-29)

• Remove all dependencies previously needed by loguru (on Windows platform, it solely remains colorama and win32-setctime).
• Add a new logger.patch() method which can be used to modify the record dict on-the-fly before it's being sent to the handlers.
• Modify behavior of sink option backtrace so it only extends the stacktrace upward, the display of variables values is now controlled with the new diagnose argument (#49).
• Change behavior of rotation option in file sinks: it is now based on the file creation time rather than the current time, note that proper support may differ depending on your platform (#58).
• Raise errors on unknowns color tags rather than silently ignoring them (#57).
• Add the possibility to auto-close color tags by using </> (e.g. <yellow>message</>).
• Add coloration of exception traceback even if diagnose and backtrace options are False.
• Add a way to limit the depth of formatted exceptions traceback by setting the conventional sys.tracebacklimit variable (#77).
• Add __repr__ value to the logger for convenient debugging (#84).
• Remove colors tags mixing directives (e.g. <red,blue>) for simplification.
• Make the record["exception"] attribute unpackable as a (type, value, traceback) tuple.
• Fix error happening in some rare circumstances because frame.f_globals dict did not contain "__name__" key and hence prevented Loguru to retrieve the module's name. From now, record["name"] will be equal to None in such case (#62).
• Fix logging methods not being serializable with pickle and hence raising exception while being passed to some multiprocessing functions (#102).
• Fix exception stack trace not colorizing source code lines on Windows.
• Fix possible AttributeError while formatting exceptions within a celery task (#52).
• Fix logger.catch decorator not working with generator and coroutine functions (#75).
• Fix record["path"] case being normalized for no necessary reason (#85).
• Fix some Windows terminal emulators (mintty) not correctly detected as supporting colors, causing ansi codes to be automatically stripped (#104).
• Fix handler added with enqueue=True stopping working if exception was raised in sink although catch=True.
• Fix thread-safety of enable() and disable() being called during logging.
• Use Tox to run tests (#41).

0.2.5 (2019-01-20)

• Modify behavior of sink option backtrace=False so it doesn't extend traceback upward automatically (#30).
• Fix import error on some platforms using Python 3.5 with limited localtime() support (#33).
• Fix incorrect time formatting of locale month using MMM and MMMM tokens (#34, thanks @nasyxx).
• Fix race condition permitting writing on a stopped handler.

0.2.4 (2018-12-26)

• Fix adding handler while logging which was not thread-safe (#22).

0.2.3 (2018-12-16)

• Add support for PyPy.
• Add support for Python 3.5.
• Fix incompatibility with awscli by downgrading required colorama dependency version (#12).

0.2.2 (2018-12-12)

• Deprecate logger.start() and logger.stop() methods in favor of logger.add() and logger.remove() (#3).
• Fix ignored formatting while using logging.Handler sinks (#4).
• Fix impossibility to set empty environment variable color on Windows (#7).

0.2.1 (2018-12-08)

• Fix typo preventing README to be correctly displayed on PyPI.

0.2.0 (2018-12-08)

• Remove the parser and refactor it into the logger.parse() method.
• Remove the notifier and its dependencies (pip install notifiers should be used instead).

0.1.0 (2018-12-07)

• Add logger.
• Add notifier.
• Add parser.

0.0.1 (2017-09-04)

Initial release.