Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:38
📄 __about__.py __version__ = "0.11.1"	23 B	2025-05-25 12:39
📄 __init__.py	0 B	2025-05-25 12:39
📁 __pycache__	-	2025-05-25 12:39
📄 asynchandler.py from fluent import asyncsender, handler class FluentHandler(handler.FluentHandler): """ Asynchronous Logging Handler for fluent. """ def getSenderClass(self): return asyncsender.FluentSender	218 B	2025-05-25 12:39
📄 asyncsender.py import threading from queue import Empty, Full, Queue from fluent import sender from fluent.sender import EventTime __all__ = ["EventTime", "FluentSender"] DEFAULT_QUEUE_MAXSIZE = 100 DEFAULT_QUEUE_CIRCULAR = False _TOMBSTONE = object() _global_sender = None def _set_global_sender(sender): # pragma: no cover """[For testing] Function to set global sender directly""" global _global_sender _global_sender = sender def setup(tag, kwargs): # pragma: no cover global _global_sender _global_sender = FluentSender(tag, kwargs) def get_global_sender(): # pragma: no cover return _global_sender def close(): # pragma: no cover get_global_sender().close() class FluentSender(sender.FluentSender): def __init__( self, tag, host="localhost", port=24224, bufmax=1 * 1024 * 1024, timeout=3.0, verbose=False, buffer_overflow_handler=None, nanosecond_precision=False, msgpack_kwargs=None, queue_maxsize=DEFAULT_QUEUE_MAXSIZE, queue_circular=DEFAULT_QUEUE_CIRCULAR, queue_overflow_handler=None, kwargs, ): """ :param kwargs: This kwargs argument is not used in __init__. This will be removed in the next major version. """ super().__init__( tag=tag, host=host, port=port, bufmax=bufmax, timeout=timeout, verbose=verbose, buffer_overflow_handler=buffer_overflow_handler, nanosecond_precision=nanosecond_precision, msgpack_kwargs=msgpack_kwargs, kwargs, ) self._queue_maxsize = queue_maxsize self._queue_circular = queue_circular if queue_circular and queue_overflow_handler: self._queue_overflow_handler = queue_overflow_handler else: self._queue_overflow_handler = self._queue_overflow_handler_default self._thread_guard = ( threading.Event() ) # This ensures visibility across all variables self._closed = False self._queue = Queue(maxsize=queue_maxsize) self._send_thread = threading.Thread( target=self._send_loop, name="AsyncFluentSender %d" % id(self) ) self._send_thread.daemon = True self._send_thread.start() def close(self, flush=True): with self.lock: if self._closed: return self._closed = True if not flush: while True: try: self._queue.get(block=False) except Empty: break self._queue.put(_TOMBSTONE) self._send_thread.join() @property def queue_maxsize(self): return self._queue_maxsize @property def queue_blocking(self): return not self._queue_circular @property def queue_circular(self): return self._queue_circular def _send(self, bytes_): with self.lock: if self._closed: return False if self._queue_circular and self._queue.full(): # discard oldest try: discarded_bytes = self._queue.get(block=False) except Empty: # pragma: no cover pass else: self._queue_overflow_handler(discarded_bytes) try: self._queue.put(bytes_, block=(not self._queue_circular)) except Full: # pragma: no cover return False # this actually can't happen return True def _send_loop(self): send_internal = super()._send_internal try: while True: bytes_ = self._queue.get(block=True) if bytes_ is _TOMBSTONE: break send_internal(bytes_) finally: self._close() def _queue_overflow_handler_default(self, discarded_bytes): pass def __exit__(self, exc_type, exc_val, exc_tb): self.close()	4.09 KB	2025-05-25 12:39
📄 event.py from fluent import sender class Event: def __init__(self, label, data, **kwargs): assert isinstance(data, dict), "data must be a dict" sender_ = kwargs.get("sender", sender.get_global_sender()) timestamp = kwargs.get("time", None) if timestamp is not None: sender_.emit_with_time(label, timestamp, data) else: sender_.emit(label, data)	406 B	2025-05-25 12:39
📄 handler.py import json import logging import socket from fluent import sender class FluentRecordFormatter(logging.Formatter): """A structured formatter for Fluent. Best used with server storing data in an ElasticSearch cluster for example. :param fmt: a dict or a callable with format string as values to map to provided keys. If callable, should accept a single argument `LogRecord` and return a dict, and have a field `usesTime` that is callable and return a bool as would `FluentRecordFormatter.usesTime` :param datefmt: strftime()-compatible date/time format string. :param style: '%', '{' or '$' (used only with Python 3.2 or above) :param fill_missing_fmt_key: if True, do not raise a KeyError if the format key is not found. Put None if not found. :param format_json: if True, will attempt to parse message as json. If not, will use message as-is. Defaults to True :param exclude_attrs: switches this formatter into a mode where all attributes except the ones specified by `exclude_attrs` are logged with the record as is. If `None`, operates as before, otherwise `fmt` is ignored. Can be an iterable. """ def __init__( self, fmt=None, datefmt=None, style="%", fill_missing_fmt_key=False, format_json=True, exclude_attrs=None, ): super().__init__(None, datefmt) if style != "%": self.__style, basic_fmt_dict = { "{": ( logging.StrFormatStyle, { "sys_host": "{hostname}", "sys_name": "{name}", "sys_module": "{module}", }, ), "$": ( logging.StringTemplateStyle, { "sys_host": "${hostname}", "sys_name": "${name}", "sys_module": "${module}", }, ), }[style] else: self.__style = None basic_fmt_dict = { "sys_host": "%(hostname)s", "sys_name": "%(name)s", "sys_module": "%(module)s", } if exclude_attrs is not None: self._exc_attrs = set(exclude_attrs) self._fmt_dict = None self._formatter = self._format_by_exclusion self.usesTime = super().usesTime else: self._exc_attrs = None if not fmt: self._fmt_dict = basic_fmt_dict self._formatter = self._format_by_dict self.usesTime = self._format_by_dict_uses_time else: if callable(fmt): self._formatter = fmt self.usesTime = fmt.usesTime else: self._fmt_dict = fmt self._formatter = self._format_by_dict self.usesTime = self._format_by_dict_uses_time if format_json: self._format_msg = self._format_msg_json else: self._format_msg = self._format_msg_default self.hostname = socket.gethostname() self.fill_missing_fmt_key = fill_missing_fmt_key def format(self, record): # Compute attributes handled by parent class. super().format(record) # Add ours record.hostname = self.hostname # Apply format data = self._formatter(record) self._structuring(data, record) return data def usesTime(self): """This method is substituted on construction based on settings for performance reasons""" def _structuring(self, data, record): """Melds `msg` into `data`. :param data: dictionary to be sent to fluent server :param msg: :class:`LogRecord`'s message to add to `data`. `msg` can be a simple string for backward compatibility with :mod:`logging` framework, a JSON encoded string or a dictionary that will be merged into dictionary generated in :meth:`format. """ msg = record.msg if isinstance(msg, dict): self._add_dic(data, msg) elif isinstance(msg, str): self._add_dic(data, self._format_msg(record, msg)) else: self._add_dic(data, {"message": msg}) def _format_msg_json(self, record, msg): try: json_msg = json.loads(str(msg)) if isinstance(json_msg, dict): return json_msg else: return self._format_msg_default(record, msg) except ValueError: return self._format_msg_default(record, msg) def _format_msg_default(self, record, msg): return {"message": super().format(record)} def _format_by_exclusion(self, record): data = {} for key, value in record.__dict__.items(): if key not in self._exc_attrs: data[key] = value return data def _format_by_dict(self, record): data = {} for key, value in self._fmt_dict.items(): try: if self.__style: value = self.__style(value).format(record) else: value = value % record.__dict__ except KeyError as exc: value = None if not self.fill_missing_fmt_key: raise exc data[key] = value return data def _format_by_dict_uses_time(self): if self.__style: search = self.__style.asctime_search else: search = "%(asctime)" return any([value.find(search) >= 0 for value in self._fmt_dict.values()]) @staticmethod def _add_dic(data, dic): for key, value in dic.items(): if isinstance(key, str): data[key] = value class FluentHandler(logging.Handler): """ Logging Handler for fluent. """ def __init__( self, tag, host="localhost", port=24224, timeout=3.0, verbose=False, buffer_overflow_handler=None, msgpack_kwargs=None, nanosecond_precision=False, kwargs, ): self.tag = tag self._host = host self._port = port self._timeout = timeout self._verbose = verbose self._buffer_overflow_handler = buffer_overflow_handler self._msgpack_kwargs = msgpack_kwargs self._nanosecond_precision = nanosecond_precision self._kwargs = kwargs self._sender = None logging.Handler.__init__(self) def getSenderClass(self): return sender.FluentSender @property def sender(self): if self._sender is None: self._sender = self.getSenderInstance( tag=self.tag, host=self._host, port=self._port, timeout=self._timeout, verbose=self._verbose, buffer_overflow_handler=self._buffer_overflow_handler, msgpack_kwargs=self._msgpack_kwargs, nanosecond_precision=self._nanosecond_precision, self._kwargs, ) return self._sender def getSenderInstance( self, tag, host, port, timeout, verbose, buffer_overflow_handler, msgpack_kwargs, nanosecond_precision, kwargs, ): sender_class = self.getSenderClass() return sender_class( tag, host=host, port=port, timeout=timeout, verbose=verbose, buffer_overflow_handler=buffer_overflow_handler, msgpack_kwargs=msgpack_kwargs, nanosecond_precision=nanosecond_precision, kwargs, ) def emit(self, record): data = self.format(record) _sender = self.sender return _sender.emit_with_time( None, sender.EventTime(record.created) if _sender.nanosecond_precision else int(record.created), data, ) def close(self): self.acquire() try: try: if self._sender is not None: self._sender.close() self._sender = None finally: super().close() finally: self.release() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.close()	8.54 KB	2025-05-25 12:39
📄 sender.py import errno import socket import struct import threading import time import traceback import msgpack _global_sender = None def _set_global_sender(sender): # pragma: no cover """[For testing] Function to set global sender directly""" global _global_sender _global_sender = sender def setup(tag, kwargs): # pragma: no cover global _global_sender _global_sender = FluentSender(tag, kwargs) def get_global_sender(): # pragma: no cover return _global_sender def close(): # pragma: no cover get_global_sender().close() class EventTime(msgpack.ExtType): def __new__(cls, timestamp, nanoseconds=None): seconds = int(timestamp) if nanoseconds is None: nanoseconds = int(timestamp % 1 * 109) return super().__new__( cls, code=0, data=struct.pack(">II", seconds, nanoseconds), ) @classmethod def from_unix_nano(cls, unix_nano): seconds, nanos = divmod(unix_nano, 109) return cls(seconds, nanos) class FluentSender: def __init__( self, tag, host="localhost", port=24224, bufmax=1 * 1024 * 1024, timeout=3.0, verbose=False, buffer_overflow_handler=None, nanosecond_precision=False, msgpack_kwargs=None, , forward_packet_error=True, kwargs, ): """ :param kwargs: This kwargs argument is not used in __init__. This will be removed in the next major version. """ self.tag = tag self.host = host self.port = port self.bufmax = bufmax self.timeout = timeout self.verbose = verbose self.buffer_overflow_handler = buffer_overflow_handler self.nanosecond_precision = nanosecond_precision self.forward_packet_error = forward_packet_error self.msgpack_kwargs = {} if msgpack_kwargs is None else msgpack_kwargs self.socket = None self.pendings = None self.lock = threading.Lock() self._closed = False self._last_error_threadlocal = threading.local() def emit(self, label, data): if self.nanosecond_precision: cur_time = EventTime.from_unix_nano(time.time_ns()) else: cur_time = int(time.time()) return self.emit_with_time(label, cur_time, data) def emit_with_time(self, label, timestamp, data): try: bytes_ = self._make_packet(label, timestamp, data) except Exception as e: if not self.forward_packet_error: raise self.last_error = e bytes_ = self._make_packet( label, timestamp, { "level": "CRITICAL", "message": "Can't output to log", "traceback": traceback.format_exc(), }, ) return self._send(bytes_) @property def last_error(self): return getattr(self._last_error_threadlocal, "exception", None) @last_error.setter def last_error(self, err): self._last_error_threadlocal.exception = err def clear_last_error(self, _thread_id=None): if hasattr(self._last_error_threadlocal, "exception"): delattr(self._last_error_threadlocal, "exception") def close(self): with self.lock: if self._closed: return self._closed = True if self.pendings: try: self._send_data(self.pendings) except Exception: self._call_buffer_overflow_handler(self.pendings) self._close() self.pendings = None def _make_packet(self, label, timestamp, data): if label: tag = f"{self.tag}.{label}" if self.tag else label else: tag = self.tag if self.nanosecond_precision and isinstance(timestamp, float): timestamp = EventTime(timestamp) packet = (tag, timestamp, data) if self.verbose: print(packet) return msgpack.packb(packet, *self.msgpack_kwargs) def _send(self, bytes_): with self.lock: if self._closed: return False return self._send_internal(bytes_) def _send_internal(self, bytes_): # buffering if self.pendings: self.pendings += bytes_ bytes_ = self.pendings try: self._send_data(bytes_) # send finished self.pendings = None return True except OSError as e: self.last_error = e # close socket self._close() # clear buffer if it exceeds max buffer size if self.pendings and (len(self.pendings) > self.bufmax): self._call_buffer_overflow_handler(self.pendings) self.pendings = None else: self.pendings = bytes_ return False def _check_recv_side(self): try: self.socket.settimeout(0.0) try: recvd = self.socket.recv(4096) except OSError as recv_e: if recv_e.errno != errno.EWOULDBLOCK: raise return if recvd == b"": raise OSError(errno.EPIPE, "Broken pipe") finally: self.socket.settimeout(self.timeout) def _send_data(self, bytes_): # reconnect if possible self._reconnect() # send message bytes_to_send = len(bytes_) bytes_sent = 0 self._check_recv_side() while bytes_sent < bytes_to_send: sent = self.socket.send(bytes_[bytes_sent:]) if sent == 0: raise OSError(errno.EPIPE, "Broken pipe") bytes_sent += sent self._check_recv_side() def _reconnect(self): if not self.socket: try: if self.host.startswith("unix://"): sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.settimeout(self.timeout) sock.connect(self.host[len("unix://") :]) else: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(self.timeout) # This might be controversial and may need to be removed sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) sock.connect((self.host, self.port)) except Exception as e: try: sock.close() except Exception: # pragma: no cover pass raise e else: self.socket = sock def _call_buffer_overflow_handler(self, pending_events): try: if self.buffer_overflow_handler: self.buffer_overflow_handler(pending_events) except Exception: # User should care any exception in handler pass def _close(self): try: sock = self.socket if sock: try: try: sock.shutdown(socket.SHUT_RDWR) except OSError: # pragma: no cover pass finally: try: sock.close() except OSError: # pragma: no cover pass finally: self.socket = None def __enter__(self): return self def __exit__(self, typ, value, traceback): try: self.close() except Exception as e: # pragma: no cover self.last_error = e	7.72 KB	2025-05-25 12:39

Terminal