8j 7ddlmZddlZddlZddlZddlZddlmZddlmZmZddlm Z ddl m Z m Z m Z ddlmZe rddlmZdd lmZmZdd lmZdd lmZGd d ZedGddeZedGddeZy)) annotationsN)Task)UTCdatetime)Thread) TYPE_CHECKINGClassVarSelf) docs_group) TracebackType) LogClientLogClientAsync) HttpResponse)Timeoutc^eZdZUdZdZ dZded< ddddZdd Zdd dd Z e dd Z y )StreamedLogBasez>Base class for streaming and buffering chunked Actor run logs.F no_timeoutzClassVar[Timeout]_stream_timeoutT from_startc|jrd|_||_tt|_t jd|_|rd|_ ytjt|_ y)NTs5(?:\n|^)(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z))tz) _force_propagate propagate _to_loggerlistbytes_stream_bufferrecompile _split_markerrnowr_relevancy_time_limit)self to_loggerrs Q/var/www/html/GAP/venv/lib/python3.12/site-packages/apify_client/_streamed_log.py__init__zStreamedLogBase.__init__#sU  "&I #"5kmZZ(ab>Hd"hll^aNb"c|}|jj|tj|j|r|j dyy)NFinclude_last_part)rappendrfindallr!_log_buffer_content)r$data new_chunks r&_process_new_dataz!StreamedLogBase._process_new_data+sE  ""9- ::d(() 4  $ $u $ = 5r(r*c4tj|jdj|jdd}|r|ddd}|ddd}g|_n|ddd}|ddd}|dd|_t ||dD]\}}|j d }|j d }|jr%tj|} | |jkrY||z} |jj|j| | j y) aMerge the whole buffer and split it into parts based on the marker. Log the messages created from the split parts and remove them from buffer. The last part could be incomplete, and so it can be left unprocessed in the buffer until later. r(NrF)strictzutf-8)levelmsg)rsplitr!joinrzipdecoder#r fromisoformatrlog_guess_log_level_from_messagestrip) r$r+ all_partsmessage_markersmessage_contentsmarkercontentdecoded_markerdecoded_contentlog_timemessages r&r.z#StreamedLogBase._log_buffer_content2s& HHT//$:M:M1NOPQPRS '1oO(A "$D '"Q/O(2a0 "+BC.D "?4DUS hOFG#]]73N%nnW5O))#11.Ad888$6G OO  d&H&H&QW^WdWdWf  g hr(crd}tj}|D] }||vs||cStjS)z%Guess the log level from the message.)CRITICALFATALERRORWARNWARNINGINFODEBUGNOTSET)logginggetLevelNamesMappingrP)rI known_levelslevel_names_to_levelsr7s r&r?z-StreamedLogBase._guess_log_level_from_messageNsGd ' < < >! 4E,U33 4||r(N)r%logging.LoggerrboolreturnNone)r/rrYrZ)r+rXrYrZ)rIstrrYint) __name__ __module__ __qualname____doc__rr__annotations__r'r1r. staticmethodr?r(r&rrsQH_)5O&5 IMc>@Eh8  r(rOthercteZdZUdZdZded< ddd fdZddZdd Zdd Z dd Z dd Z xZ S) StreamedLogaStreams Actor run log output to a Python logger in a background thread. The log stream is consumed in a background thread and each log message is forwarded to the provided logger with an appropriate log level inferred from the message content. Can be used as a context manager, which automatically starts and stops the streaming thread. Alternatively, call `start` and `stop` manually. Obtain an instance via `RunClient.get_streamed_log`. zClassVar[float]_stop_timeout_sTrc`t|||||_d|_d|_d|_y)aInitialize `StreamedLog`. Args: log_client: The log client used to stream raw log data from the Actor run. to_logger: The logger to which the log messages will be forwarded. from_start: If `True`, all logs from the start of the Actor run will be streamed. If `False`, only newly arrived logs will be streamed. This can be useful for long-running Actors in stand-by mode where only recent logs are relevant. r%rNF)superr' _log_client_streaming_thread _log_stream _stop_loggingr$ log_clientr%r __class__s r&r'zStreamedLog.__init__ms7 9D%0404"r(c |jr%|jjr tdd|_t j |j d|_|jj|jS)z{Start the streaming thread. The caller is responsible for cleanup by calling the `stop` method when done. zStreaming thread already activeFT)targetdaemon)rmis_alive RuntimeErrorro threadingr _stream_logstartr$s r&rzzStreamedLog.start}sl  ! !d&<&<&E&E&G@A A"!*!1!19I9IRV!W $$&%%%r(c|js tdd|_|j}| |j |jj|j|jjr|j jdyd|_y#t $r|j jdYwxYw)aSignal the streaming thread to stop logging and wait up to `_stop_timeout_s` for it to finish. A thread that outlives the wait is a daemon with `_stop_logging` set, so it exits after at most one more chunk, and only then does its buffered tail reach the logger. Its handle is kept while it is alive, so `start` cannot revive it beside a second thread on the same buffer. zStreaming thread is not activeTNzClosing the log stream failed:)timeoutzMLog streaming thread outlived the stop timeout; it ends after the next chunk.) rmrwrornclose Exceptionr exceptionr:rhrvdebug)r$ log_streams r&stopzStreamedLog.stops%%?@ @!%%  ! L  " ##D,@,@#A  ! ! * * , OO ! !"q r%)D " L))*JK LsB""$C C c&|j|S)zdStart the streaming thread within the context. Exiting the context will finish the streaming thread.rzr{s r& __enter__zStreamedLog.__enter__s  r(c$|jy)zStop the streaming thread.Nrr$exc_typeexc_valexc_tbs r&__exit__zStreamedLog.__exit__s  r(c$ |jjd|j5}|s dddy||_ |jr$ d|_ |j ddddy|jD]!}|j||js!nd|_ |j ddddy#t $r|jjdYwxYw#t $r|jjdYYwxYw#d|_ |j dw#t $r|jjdYwwxYwxYw#1swYyxYw#t $r}|jr!|jjd|Yd}~y|jjj|r|jjdn |jjdYd}~yYd}~yd}~wwxYw)NTrawr}r*0Log redirection stopped due to unexpected error:z6Log streaming stopped while `stop` was in progress: %r8Log streaming stopped: the log stream request timed out.)rlstreamrrnror.rrr iter_bytesr1r _http_clientis_timeout_errorwarningr$rr/excs r&ryzStreamedLog._stream_logs ! ^!!((T4;O;O(P fT^! f f$. f)) (,D$f0040H# f f!+ 5 5 7"..t4--!" (,D$f0040H# f f$%f112def9f112def (,D$f0040H$f112def% f f, ^!!%%&^`cd,,==cB''(bc))*\]]d ^s'E.E"E.E" D E"C%E..0DD"E"*C/<E.$C,)E"+C,,E"/$DE"DE"E"D54E5$E EE EE""E+'E.+E.. H7(H $AH  H)rqr r%rWrrXrYrZ)rYrrYrZrYr rztype[BaseException] | NonerzBaseException | NonerzTracebackType | NonerYrZ) r]r^r_r`rhrar'rzrrrry __classcell__rrs@r&rfrf[s_()O_( `d# &*2 2=Q[o  "^r(rfcbeZdZdZddd fdZd dZd dZd dZ ddZd d Z xZ S)StreamedLogAsyncaStreams Actor run log output to a Python logger in an asyncio task. The log stream is consumed in a background asyncio task and each log message is forwarded to the provided logger with an appropriate log level inferred from the message content. Can be used as an async context manager, which automatically starts and cancels the streaming task. Alternatively, call `start` and `stop` manually. Obtain an instance via `RunClientAsync.get_streamed_log`. TrcDt|||||_d|_y)aInitialize `StreamedLogAsync`. Args: log_client: The async log client used to stream raw log data from the Actor run. to_logger: The logger to which the log messages will be forwarded. from_start: If `True`, all logs from the start of the Actor run will be streamed. If `False`, only newly arrived logs will be streamed. This can be useful for long-running Actors in stand-by mode where only recent logs are relevant. rjN)rkr'rl_streaming_taskrps r&r'zStreamedLogAsync.__init__s' 9D%,0r(c|jr%|jjs tdtj|j |_|jS)zyStart the streaming task. The caller is responsible for cleanup by calling the `stop` method when done. zStreaming task already active)rdonerwasyncio create_taskryr{s r&rzzStreamedLogAsync.startsR   (<(<(A(A(C>? ?&2243C3C3EF###r(cK|js td|jj |jd{d|_y7 #tj$rYwxYw#d|_wxYww)zStop the streaming task.zStreaming task is not activeN)rrwcancelrCancelledErrorr{s r&rzStreamedLogAsync.stopsr##=> > ##% (&& & &$(D '%%   $(D sF2A8AAA A8AA)&A,(A))A,, A55A8c.K|j|Sw)z`Start the streaming task within the context. Exiting the context will cancel the streaming task.rr{s r& __aenter__zStreamedLogAsync.__aenter__s  sc@K|jd{y7w)zCancel the streaming task.Nrrs r& __aexit__zStreamedLogAsync.__aexit__siiks c8K |jjd|j4d{}|s dddd{y |j23d{}|j |7D7376 |j dnl#t $r|jjdYnFwxYw# |j dw#t $r|jjdYwwxYwxYwdddd{7y#1d{7swYyxYw#t $rk}|jjj|r|jjdn |jjdYd}~yYd}~yd}~wwxYww)NTrr*rr) rlrr aiter_bytesr1r.rrrrrrrs r&ryzStreamedLogAsync._stream_logs ^''..4AUAU.V f fZd! f f f f&0&<&<&>55d..t4 f f5&>f0040H$f112deff0040H$f112def f f f f f ^,,==cB''(bc))*\]]d ^sF+D#A4D#D D#A6D#F B:A:A8A:!B:4D#6D#8A::B:=BD$B74D6B77D:C9<CC9$C6 3C95C6 6C99D< D#D D# FD D D D#F D## F,AF FFF)rqrr%rWrrXrYrZ)rYrrrr) r]r^r_r`r'rzrrrryrrs@r&rrsNei 1$ ( 2=Q[o  ^r(r) __future__rrrSrrxrrrrtypingrr r apify_client._docsr typesr apify_client._resource_clientsr rapify_client.http_clientsrapify_client.typesrrrfrrcr(r&rs" "00)#H6*BBJ Gt^/t^t^n GP^P^P^r(