U j4@sdZddlmZddlmZddlmZmZmZm Z m Z m Z m Z ddl mZddlmZddlmZddlmZd d lmZmZd d lmZd Zd ddddZd dddddZedfdddddddZefd dddddZdd d!d"d#d$ZGd%d!d!e Z!Gd&d'd'e e"efZ#dd(dd)d*d+Z$d ddd,d-Z%d.dd/d0d1Z&d ddd2d3Z'd4d4d4efd d5d5d5d6dd7d8d9Z(d:S);z& Tools for formatting logging events. ) annotations)datetime)AnyCallableIteratorMappingOptionalUnioncast) NamedConstant)FixedOffsetTimeZone)Failure) safe_repr) aFormatter flatFormat)LogEventz%Y-%m-%dT%H:%M:%S%zrstr)eventreturncCst|ddddS)aa Formats an event as text, using the format in C{event["log_format"]}. This implementation should never raise an exception; if the formatting cannot be done, the returned string will describe the event generically so that a useful message is emitted regardless. @param event: A logging event. @return: A formatted string. F)includeTracebackincludeTimestamp includeSystem) eventAsText)rr:/tmp/pip-unpacked-wheel-j5h_c8_q/twisted/logger/_format.py formatEvents r BaseException)rerrorrcCs\zdj||dWStk rVt}ddd|D}djt|||dYSXdS) z Formats an event as text that describes the event generically and a formatting error. @param event: A logging event. @param error: The formatting error. @return: A formatted string. z)Unable to format event {event!r}: {error})rrz, css(|] \}}dt|t|fVqdS)z = N)joinr).0keyvaluerrr Csz+formatUnformattableEvent..zrMESSAGE LOST: unformattable object logged: {error} Recoverable data: {text} Exception during formatting: {failure})rfailuretextN)formatrr ritemsr)rrr$r%rrrformatUnformattableEvent-s  r(-zOptional[float]z Optional[str])when timeFormatdefaultrcCs<|dks|dkr|St|}t||}t||SdS)a Format a timestamp as text. Example:: >>> from time import time >>> from twisted.logger import formatTime >>> >>> t = time() >>> formatTime(t) u'2013-10-22T14:19:11-0700' >>> formatTime(t, timeFormat="%Y/%W") # Year and week number u'2013/42' >>> @param when: A timestamp. @param timeFormat: A time format. @param default: Text to return if C{when} or C{timeFormat} is L{None}. @return: A formatted time. N)r ZfromLocalTimeStampDateTime fromtimestamprstrftime)r*r+r,tzrrrr formatTimeQs   r1z Callable[[Optional[float]], str])rr1rcCs(t||d}|sdS|dd}|dS)a& Format an event as a line of human-readable text for, e.g. traditional log file output. The output format is C{"{timeStamp} [{system}] {event}\n"}, where: - C{timeStamp} is computed by calling the given C{formatTime} callable on the event's C{"log_time"} value - C{system} is the event's C{"log_system"} value, if set, otherwise, the C{"log_namespace"} and C{"log_level"}, joined by a C{"#"}. Each defaults to C{"-"} is not set. - C{event} is the event, as formatted by L{formatEvent}. Example:: >>> from time import time >>> from twisted.logger import formatEventAsClassicLogText >>> from twisted.logger import LogLevel >>> >>> formatEventAsClassicLogText(dict()) # No format, returns None >>> formatEventAsClassicLogText(dict(log_format="Hello!")) u'- [-#-] Hello!\n' >>> formatEventAsClassicLogText(dict( ... log_format="Hello!", ... log_time=time(), ... log_namespace="my_namespace", ... log_level=LogLevel.info, ... )) u'2013-10-22T17:30:02-0700 [my_namespace#info] Hello!\n' >>> formatEventAsClassicLogText(dict( ... log_format="Hello!", ... log_time=time(), ... log_system="my_system", ... )) u'2013-11-11T17:22:06-0800 [my_system] Hello!\n' >>> @param event: an event. @param formatTime: A time formatter @return: A formatted event, or L{None} if no output is appropriate. )r1N z )rreplace)rr1 eventTextrrrformatEventAsClassicLogTextss /  r5zCallable[[str], Any]PotentialCallWrapper)r!getterrcCs8|d}|r|ddn|}||}|r0|}t|S)at Check to see if C{key} ends with parentheses ("C{()}"); if not, wrap up the result of C{get} in a L{PotentialCallWrapper}. Otherwise, call the result of C{get} first, before wrapping it up. @param key: The last dotted segment of a formatting key, as parsed by L{Formatter.vformat}, which may end in C{()}. @param getter: A function which takes a string and returns some other object, to be formatted and stringified for a log. @return: A L{PotentialCallWrapper} that will wrap up the result to allow for subsequent usages of parens to defer execution to log-format time. z()N)endswithr6)r!r7ZcallitZrealKeyr"rrrkeycalls  r:c@sleZdZdZdddddZdddd d Zdddd d Zddd ddZddddZddddZ dS)r6z Object wrapper that wraps C{getattr()} so as to process call-parentheses C{"()"} after a dotted attribute access. objectNone)wrappedrcCs ||_dSN)_wrapped)selfr=rrr__init__szPotentialCallWrapper.__init__r)namercst|fddS)Ncs tj|Sr>)getattrr?)Zname_r@rrz2PotentialCallWrapper.__getattr__..)r:)r@rBrrDr __getattr__sz PotentialCallWrapper.__getattr__cCs|j|}t|Sr>)r?r6)r@rBr"rrr __getitem__s z PotentialCallWrapper.__getitem__) format_specrcCs t|j|Sr>)r&r?)r@rIrrr __format__szPotentialCallWrapper.__format__rcCs t|jSr>)reprr?rDrrr__repr__szPotentialCallWrapper.__repr__cCs t|jSr>)rr?rDrrr__str__szPotentialCallWrapper.__str__N) __name__ __module__ __qualname____doc__rArGrHrJrMrNrrrrr6sc@sLeZdZdZdddddZddd d Zd dd d ZdddddZdS) CallMappingz Read-only mapping that turns a C{()}-suffix in key names into an invocation of the key rather than a lookup of the key. Implementation support for L{formatWithCall}. Mapping[str, Any]r<) submappingrcCs ||_dS)zo @param submapping: Another read-only mapping which will be used to look up items. N) _submapping)r@rUrrrrAszCallMapping.__init__z Iterator[Any]rKcCs t|jSr>)iterrVrDrrr__iter__szCallMapping.__iter__intcCs t|jSr>)lenrVrDrrr__len__szCallMapping.__len__rr)r!rcCst||jjS)z| Look up an item in the submapping for this L{CallMapping}, calling it if C{key} ends with C{"()"}. )r:rVrH)r@r!rrrrHszCallMapping.__getitem__N)rOrPrQrRrArXr[rHrrrrrSs rSrT) formatStringmappingrcCstt|dt|S)a Format a string like L{str.format}, but: - taking only a name mapping; no positional arguments - with the additional syntax that an empty set of parentheses correspond to a formatting item that should be called, and its result C{str}'d, rather than calling C{str} on the element directly as normal. For example:: >>> formatWithCall("{string}, {function()}.", ... dict(string="just a string", ... function=lambda: "a function")) 'just a string, a function.' @param formatString: A PEP-3101 format string. @param mapping: A L{dict}-like object to format. @return: The string with formatted values interpolated. r)rrvformatrS)r\r]rrrformatWithCallsr_c Cszzd|krt|WStttttf|dd}|dkr@WdSt|trLn$t|trb|d}nt d|t ||WSt k r}zt ||WYSd}~XYnXdS)ae Formats an event as a string, using the format in C{event["log_format"]}. This implementation should never raise an exception; if the formatting cannot be done, the returned string will describe the event generically so that a useful message is emitted regardless. @param event: A logging event. @return: A formatted string. Z log_flattenedZ log_formatNzutf-8zLog format must be str, not ) rr rr rbytesget isinstancedecode TypeErrorr_rr()rr&errr _formatEvents      rgr )r$rc Cs@z |}Wn.tk r:}zdt|}W5d}~XYnX|S)a^ Format a failure traceback, assuming UTF-8 and using a replacement strategy for errors. Every effort is made to provide a usable traceback, but should not that not be possible, a message and the captured exception are logged. @param failure: The failure to retrieve a traceback from. @return: The formatted traceback. z((UNABLE TO OBTAIN TRACEBACK FROM EVENT):N)Z getTracebackrr)r$ tracebackrfrrr_formatTraceback5s  ricCsttt|dd}|dkrfttt|dd}|dkrBd}n|j}djtt|dd|d}n&z t|}Wntk rd}YnX|S) a Format the system specified in the event in the "log_system" key if set, otherwise the C{"log_namespace"} and C{"log_level"}, joined by a C{"#"}. Each defaults to C{"-"} is not set. If formatting fails completely, "UNFORMATTABLE" is returned. @param event: The event containing the system specification. @return: A formatted string representing the "log_system" key. Z log_systemNZ log_levelr)z{namespace}#{level}Z log_namespace) namespacelevelZ UNFORMATTABLE)r rrrbr rBr& Exception)rsystemrk levelNamerrr _formatSystemGs   roTboolzCallable[[float], str])rrrrr1rc Cst|}|r2d|kr2|d}t|}d||f}|s:|Sd}|rbd|tt|dddg}d} |rddt|ddg} d j|| |d S) ah Format an event as text. Optionally, attach timestamp, traceback, and system information. The full output format is: C{"{timeStamp} [{system}] {event}\n{traceback}\n"} where: - C{timeStamp} is the event's C{"log_time"} value formatted with the provided C{formatTime} callable. - C{system} is the event's C{"log_system"} value, if set, otherwise, the C{"log_namespace"} and C{"log_level"}, joined by a C{"#"}. Each defaults to C{"-"} is not set. - C{event} is the event, as formatted by L{formatEvent}. - C{traceback} is the traceback if the event contains a C{"log_failure"} key. In the event the original traceback cannot be formatted, a message indicating the failure will be substituted. If the event cannot be formatted, and no traceback exists, an empty string is returned, even if includeSystem or includeTimestamp are true. @param event: A logging event. @param includeTraceback: If true and a C{"log_failure"} key exists, append a traceback. @param includeTimestamp: If true include a formatted timestamp before the event. @param includeSystem: If true, include the event's C{"log_system"} value. @param formatTime: A time formatter @return: A formatted string with specified options. @since: Twisted 18.9.0 Z log_failurer2r`Zlog_timeN []z{timeStamp}{system}{eventText}) timeStamprmr4)rgrirr floatrbror&) rrrrr1r4frhrtrmrrrrfs$*  rN))rR __future__rrr-typingrrrrrr r Z constantlyr Ztwisted.python._tzhelperr Ztwisted.python.failurer Ztwisted.python.reflectr_flattenrrZ _interfacesrZtimeFormatRFC3339rr(r1r5r:r;r6rrSr_rgrirorrrrrs:  $     &#6"!