+ j?Rt^RIHt^RIHt^RIHt^RIHtHtH t H t H t H t ^RI Ht^RIHt^RIHtHt^RIHtHt!R R ] 4t!R R 4t!R R4t!RR4t]!4tRRltR#)z Logger class. ) annotations)time) TracebackType)AnyCallableContextManagerOptionalProtocolcast) currentframe)Failure) ILogObserverLogTrace)InvalidLogLevelErrorLogLevelc\]tRt^tRt]RRl4t]RRl4t]RRl4tRt R #) Operationz An L{Operation} represents the success (or lack thereof) of code performed within the body of the L{Logger.failureHandler} context manager. cV^8dQhRR/#returnbool)formats"8/usr/lib/python3/dist-packages/twisted/logger/_logger.py __annotate__Operation.__annotate__s  4 c R#)z Did the operation succeed? C{True} iff the code completed without raising an exception; C{False} while the code is running and C{False} if it raises an exception. Nrselfs&r succeededOperation.succeededrcV^8dQhRR/#)rrFailure | Noner)rs"rrr$s   rc R#)zR Did the operation raise an exception? If so, this L{Failure} is that exception. Nrrs&rfailureOperation.failure#r#rcV^8dQhRR/#rr)rs"rrr+s   rc R#)z Did the operation fail? C{True} iff the code raised an exception; C{False} while the code is running and C{False} if it completed without error. Nrrs&rfailedOperation.failed*r#rrN) __name__ __module__ __qualname____firstlineno____doc__propertyr!r'r+__static_attributes__rrrrrsC       rrcn]tRt^3t$RtR]R&RtR]R&RRlt]R R l4t R R lt R Rlt Rt R#) _FailCtxMgrFrr!Nr%r'c V^8dQhRRRR/#rfailzCallable[[Failure], None]rNoner)rs"rr_FailCtxMgr.__annotate__764rc WnR#N_failr r8s&&r__init___FailCtxMgr.__init__7 rcV^8dQhRR/#rr)rs"rrr:;s(((rc VPRJ#r=r'rs&rr+_FailCtxMgr.failed:s||4''rcV^8dQhRR/#)rrrr)rs"rrr:>s9rc V#r=rrs&r __enter___FailCtxMgr.__enter__>s rc(V^8dQhRRRRRRRR/# rexc_typeztype[BaseException] | None exc_valuezBaseException | None tracebackzTracebackType | Nonerrr)rs"rrr:As2  , ( (   rc bVe$\4pW@nVPV4R#RVnR#NT)r r'r?r!r rNrOrPr's"""" r__exit___FailCtxMgr.__exit__As3  iG"L JJw "DNr)r?r'r!) r-r.r/r0r!__annotations__r'rAr2r+rJrTr3rrrr5r53s>It"G^"((  rr5c:]tRt^QtRRltRRltRRltRtR#) _FastFailCtxMgrc V^8dQhRRRR/#r7r)rs"rr_FastFailCtxMgr.__annotate__Rr;rc WnR#r=r>r@s&&rrA_FastFailCtxMgr.__init__RrCrcV^8dQhRR/#)rrr9r)rs"rrrZUs  4 rc R#r=rrs&rrJ_FastFailCtxMgr.__enter__Us rc(V^8dQhRRRRRRRR/#rMr)rs"rrrZXs2  , ( (   rc PVe"\4pW@nVPV4R#rR)r r'r?rSs"""" rrT_FastFailCtxMgr.__exit__Xs%  iG"L JJw r)r?r'N)r-r.r/r0rArJrTr3rrrrXrXQs   rrXc0]tRt^ftRt]RRl4tRRRlltRRRlltR R lt RR R llt R] P3R Rllt RRRlltRRRlltRRRlltRRRlltRRRllt ] P3RRllt] P3RRlltRtR#) Loggerab A L{Logger} emits log messages to an observer. You should instantiate it as a class or module attribute, as documented in L{this module's documentation }. @ivar namespace: the namespace for this logger @ivar source: The object which is emitting events via this logger @ivar observer: The observer that this logger will send events to. cV^8dQhRR/#rrstrr)rs"rrLogger.__annotate__rs  # rc |\\\^4PR,4# \dR#i;i)z{ Derive a namespace from the module containing the caller's caller. @return: the fully qualified python name of a module. r-z )r rgr f_globalsKeyErrorrrr_namespaceFromCallingContext#Logger._namespaceFromCallingContextqs5 \!_66zBC C  s ), ;;Nc(V^8dQhRRRRRRRR/#) r namespace Optional[str]sourcezOptional[object]observerzOptional['ILogObserver']rr9r)rs"rrrh}s2%% %!%+ %  %rc vVfVP4pWnW nVf^RIHpW@nR#W0nR#)a @param namespace: The namespace for this logger. Uses a dotted notation, as used by python modules. If not L{None}, then the name of the module of the caller is used. @param source: The object which is emitting events via this logger; this is automatically set on instances of a class if this L{Logger} is an attribute of that class. @param observer: The observer that this logger will send events to. If L{None}, use the L{global log publisher }. N)globalLogPublisher)rlrorq_globalrtrr)r rorqrrrts&&&& rrALogger.__init__}s5  99;I"   3*)r}r-rors&r__repr__Logger.__repr__s'4>>**+1T^^,>a@@rc(V^8dQhRRRRRRRR/#) rlevelrrrpkwargsryrr9r)rs"rrrhs,%%%'4%GM% %rc V\P!49d*VPR\\ V44VVR7R#TpVP VVVP VPV\4R7RV9d2\\VR,4PWP34VPV4R#)a Emit a log event to all log observers at the given level. @param level: a L{LogLevel} @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. z:Got invalid log level {invalidLevel!r} in {logger}.emit().) invalidLevelloggerN) log_logger log_level log_namespace log_source log_formatlog_time log_trace) r iterconstantsr'r rupdaterorqrr rappendrr)r rrrevents&&&, remit Logger.emits ..0 0 LLL,U34"    ..{{V   %  5- . 5 5t]]6K L erc ,V^8dQhRRRRRRRRR R /#) rrrgr'zOptional[Failure]rrrryrr9r)rs"rrrhsC5@5@5@#5@ 5@  5@  5@rc LVf \4pVP!W13RV/VBR#)au Log a failure and emit a traceback. For example:: try: frob(knob) except Exception: log.failure("While frobbing {knob}", knob=knob) or:: d = deferredFrob(knob) d.addErrback(lambda f: log.failure("While frobbing {knob}", f, knob=knob)) This method is meant to capture unexpected exceptions in code; an exception that is caught and handled somehow should be logged, if appropriate, via L{Logger.error} instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure. This is done at L{LogLevel.critical} by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param failure: a L{Failure} to log. If L{None}, a L{Failure} is created from the exception in flight. @param level: a L{LogLevel} to use. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. @see: L{Logger.failureHandler} @see: L{Logger.failuresHandled} N log_failure)r r)r rr'rrs&&&&,rr'Logger.failures'd ?iG %?W??rc$V^8dQhRRRRRR/#rrrprryrr9r)rs"rrrh! 4 4M 4F 4t 4rc JVP!\PV3/VBR#)a Emit a log event at log level L{LogLevel.debug}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrdebugr rrs&&,rr Logger.debug (..&3F3rc$V^8dQhRRRRRR/#rr)rs"rrrh*! 3 3= 36 3d 3rc JVP!\PV3/VBR#)a Emit a log event at log level L{LogLevel.info}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrinfors&&,rr Logger.info* (--262rc$V^8dQhRRRRRR/#rr)rs"rrrh9rrc JVP!\PV3/VBR#)a Emit a log event at log level L{LogLevel.warn}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrwarnrs&&,rr Logger.warn9rrc$V^8dQhRRRRRR/#rr)rs"rrrhHrrc JVP!\PV3/VBR#)a Emit a log event at log level L{LogLevel.error}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrerrorrs&&,rr Logger.errorHrrc$V^8dQhRRRRRR/#rr)rs"rrrhWs! 7 7} 7v 7$ 7rc JVP!\PV3/VBR#)a Emit a log event at log level L{LogLevel.critical}. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param kwargs: additional key/value pairs to include in the event. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. N)rrcriticalrs&&,rrLogger.criticalWs (##V6v6rc(V^8dQhRRRRRRRR/#) rrrgrrrryrzContextManager[Operation]r)rs"rrrhfs2*O*O*O"**OJP*O "*Orc .aaaa\VVVV3Rl4#)a? Run some application code, logging a failure and emitting a traceback in the event that any of it fails, but continuing on. For example:: log = Logger(...) def frameworkCode() -> None: with log.failuresHandled("While frobbing {knob}:", knob=knob) as op: frob(knob) if op.succeeded: log.info("frobbed {knob} successfully", knob=knob) This method is meant to capture unexpected exceptions from application code; an exception that is caught and handled somehow should be logged, if appropriate, via L{Logger.error} instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure. This is done at L{LogLevel.critical} by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param level: a L{LogLevel} to use. @param kwargs: additional key/value pairs to include in the event, if it is emitted. Note that values which are later mutated may result in non-deterministic behavior from observers that schedule work for later execution. @see: L{Logger.failure} @see: L{Logger.failureHandler} @return: A context manager which yields an L{Operation} which will have either its C{succeeded} or C{failed} attribute set to C{True} upon completion of the code within the code within the C{with} block. c.<SP!SVS3/SB#r=rF)frrrr s&r(Logger.failuresHandled..sT\\&!U%Mf%Mr)r5)r rrrsffflrfailuresHandledLogger.failuresHandledfsTMNNrc$V^8dQhRRRRRR/#)r staticMessagergrrrzContextManager[None]r)rs"rrrhs-+P+P+P+P  +Prc *aaa\VVV3Rl4#)a For performance-sensitive frameworks that needs to handle potential failures from frequently-called application code, and do not need to include detailed structured information about the failure nor inspect the result of the operation, this method returns a context manager that will log exceptions and continue, that can be shared across multiple invocations. It should be instantiated at module scope to avoid additional object creations. For example:: log = Logger(...) ignoringFrobErrors = log.failureHandler("while frobbing:") def hotLoop() -> None: with ignoringFrobErrors: frob() This method is meant to capture unexpected exceptions from application code; an exception that is caught and handled somehow should be logged, if appropriate, via L{Logger.error} instead. If some unknown exception occurs and your code doesn't know how to handle it, as in the above example, then this method provides a means to describe the failure in nerd-speak. This is done at L{LogLevel.critical} by default, since no corrective guidance can be offered to an user/administrator, and the impact of the condition is unknown. @param format: a message format using new-style (PEP 3101) formatting. The logging event (which is a L{dict}) is used to render this format string. @param level: a L{LogLevel} to use. @see: L{Logger.failure} @return: A context manager which does not return a value, but will always exit from exceptions. c*<SPSVS4#r=rF)rrr rs&rr'Logger.failureHandler..smQ)Nr)rX)r rrsfffrfailureHandlerLogger.failureHandlersVNOOr)rorrrq)NNNr=)r-r.r/r0r1 staticmethodrlrArrrrrr'rrrrrrr3rrrrdrdfs  %: @A%T&*"++ 5@n 4 3 3 4 7 .6->->*O^#+++P+Prrdc V^8dQhRRRR/#)robjryrrdr)rs"rrrs,,F,v,rc@\PWP4#)z7 Get a L{Logger} instance attached to the given class. )_logrr})rs&r _loggerForrs <<]] ++rN)r1 __future__rrtypesrtypingrrrrr r twisted.python.compatr twisted.python.failurer _interfacesr r_levelsrrrr5rXrdrrrrrrsd #JJ.*/3  <<*WPWPt x,r