libsrg_log2web 1.0.7__py3-none-any.whl

libsrg_log2web/Demo.py

@@ -0,0 +1,67 @@
+import platform
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from time import sleep
+
+from libsrg.LoggingAppBase import LoggingAppBase
+
+from libsrg_log2web import FlaskApp, Log2Web
+from libsrg_log2web.LoggerGUIProxy import LoggerGUIProxy
+
+
+class Main(LoggingAppBase):
+
+    def __init__(self):
+
+        fmt = "%(asctime)s %(levelname)-8s %(lineno)4d %(name) 20s.%(funcName)-22s %(threadName)-12s-- %(message)s"
+        self.file0 = Path(__file__)
+        self.project_path = self.file0.parent
+        self.node = platform.node()
+        self.node0 = self.node.split(".")[0]
+
+        logfile_path = Path.home() / "Log2Web.log"
+        logfile_path.unlink(missing_ok=True)
+        self.logfile_name = str(logfile_path)
+        super().__init__(logfile=self.logfile_name, format=fmt)
+
+        self.bridge = Log2Web.Bridge(self.run, FlaskApp.app, title="Log2Web Demo",
+                                     headertext="Log2Web Demo Threads")
+        self.bridge.run()
+
+    def run(self) -> None:
+        self.logger.info("callback to application")
+
+        executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="POOL_")
+        [executor.submit(self.app_thread_target, i) for i in range(10)]
+
+        # sleep(10)
+        executor.shutdown(wait=True)
+
+        self.logger.debug("Bye")
+        # """Raises a signal to main thread which is WebGUI to shut down."""
+        # signal.raise_signal(2)
+
+    def app_thread_target(self, n: int) -> None:
+
+        LoggerGUIProxy.gui_new_line()
+        self.logger.info(f"app {n} starting")
+        for i in range(20):
+            match i:
+                case 3:
+                    LoggerGUIProxy.gui_set_colors(foreground='pink', background='blue')
+                case 5:
+                    LoggerGUIProxy.gui_set_colors(foreground='black', background='white')
+                case 7:
+                    LoggerGUIProxy.gui_set_colors(foreground='cyan', background='red')
+
+            if i == n:
+                self.logger.warning(f"app {n=} cycle {i=}")
+            else:
+                self.logger.info(f"app {n=} cycle {i=}")
+
+            sleep(1 + n / 10.)
+        LoggerGUIProxy.gui_end_line()
+
+
+if __name__ == "__main__":
+    main = Main()

libsrg_log2web/FlaskApp.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+from flask import Flask, render_template
+from libsrg_log2web.Log2Web import LogWatcher, Bridge
+
+my_file = __file__
+flask_dir = Path(my_file).parent
+app_dir = flask_dir.parent.parent
+template_dir = flask_dir / "templates"
+static_dir = flask_dir / "static"
+app = Flask(__name__,
+            template_folder=template_dir,
+            static_folder=static_dir)
+
+
+@app.route('/hello')
+def hello_world():  # put the application's code here
+    return 'Hello World!'
+
+
+@app.route('/')
+def display_status():  # put the application's code here
+    # print("prepare display list")
+    watchers = LogWatcher.instance.prepare_display_list()
+    # print("rendering template")
+    page = render_template('status.html',
+                           delay=0.25,
+                           watchers=watchers,
+                           title=Bridge.instance.title,
+                           headertext=Bridge.instance.headertext)
+    # print("returning page")
+    return page
+
+
+if __name__ == '__main__':
+    app.run()

libsrg_log2web/Log2Web.py

@@ -0,0 +1,293 @@
+import logging
+import signal
+import threading
+import webbrowser
+from threading import Thread
+from time import sleep, time
+from typing import Callable
+
+from flask import Flask
+from libsrg_log2web.LoggerGUIProxy import LogOps, LOG_OP_FMT_STRING
+"""
+This module does not import the user's Flask application module or the user's Main module.
+The user's Flask application can include the Log2Web module.
+The user's Main module must import (and instantiate) the user's FlaskApp module.
+
+The User's Main module must connect the FlaskApp module to the Log2Web module via a Bridge object.
+
+As general guidance, attempting to log within the Log2Web module may cause infinite recursion.
+"""
+
+
+
+
+
+
+"""
+ThreadLogWatcher is an object that receives log messages from a given thread and retains information for display.
+"""
+
+status_color = {
+    logging.DEBUG: 'green',
+    logging.INFO: 'blue',
+    logging.WARNING: 'orange',
+    logging.ERROR: 'red',
+    logging.CRITICAL: 'magenta'
+}
+
+
+class ThreadLogWatcher:
+    def __init__(self, record0: logging.LogRecord):
+        self.thread_id: int = record0.thread
+        self.live = True
+        self.time_of_death = None
+        self.record: logging.LogRecord = record0
+        self.fg = 'green'
+        self.bg = 'white'
+        self.worst = logging.DEBUG
+        self.latest = logging.DEBUG
+        self.tname = record0.threadName
+        self.msg = "No message yet"
+        self.args0 = record0.args
+        self.updated: bool = False
+        if len(self.args0) > 0 and isinstance(self.args0[0], LogOps):
+            print(f"created with OP {self.args0[0].name=} {type(self.args0[0])=}")
+
+    def process_log_record(self, record: logging.LogRecord):
+        # print(f"{self.thread_id} {record.getMessage()} {record.message=} {type(record.message)=} {record.args=}")
+        self.record = record
+        self.msg = record.msg
+        self.worst = max(self.worst, record.levelno)
+        self.latest = record.levelno
+        self.tname = record.threadName
+        self.updated = True
+
+    # noinspection PyUnreachableCode
+    def process_log_op(self, op: LogOps, record: logging.LogRecord, *args):
+        # print(f"PROC OP {self.thread_id}  {op=} {type(op)=} {args=}")
+        self.record = record
+        match op:
+            case LogOps.FG_COLOR:
+                self.fg = args[1]
+            case LogOps.BG_COLOR:
+                self.bg = args[1]
+            case LogOps.NEW_THREAD:
+                print(f"NEW_THREAD thread {self.thread_id} got exit OP {op=} {args=}")
+                pass  # no action, but expected
+            case LogOps.THREAD_EXIT:
+                self.live = False
+                self.time_of_death = time()
+                print(f"THREAD_EXIT {self.thread_id} got exit OP {op=} {args=}")
+            case _:
+                # noinspection PyUnreachableCode
+                print(f"Unknown OP {op=} {args=}")
+                pass
+        # print(f"PROC OP results {self.thread_id}  {self.fg=} {self.bg=}")
+
+    # noinspection PyUnusedLocal
+    def terminated(self, op: LogOps, *args):
+        # print(f"TERMINATED {self.thread_id} OP {op.name=} {type(op)=}")
+        self.live = False
+        self.time_of_death = time()
+
+    def time_dead(self, now: float) -> float | None:
+        if self.live:
+            return 0
+        return now - self.time_of_death
+
+    def display_row_start(self) -> str:
+        """HTML lead in"""
+        stat_w = status_color.get(self.worst, 'violet')
+        stat_l = status_color.get(self.latest, 'violet')
+        live_fg = 'green' if self.live else 'black'
+        live_bg = 'white' if self.live else 'lightgrey'
+        busy_fg = 'green' if self.updated else 'darkgrey'
+        self.updated = False
+        out = [
+            f"<td><span style='background-color:{live_bg};color:{live_fg};'>",
+            self.tname if self.live else f"<del>{self.tname}</del>",
+            f"</span></td>",
+
+            f"<td><span style='background-color:white;color:{stat_w};'>",
+            logging.getLevelName(self.worst),
+            f"</span></td>",
+
+            f"<td><div style='background-color:white;color:{stat_l};'>",
+            logging.getLevelName(self.latest),
+            f"</div></td>",
+
+            f"<td><div style='background-color:white;color:{busy_fg};'>",
+            f"{self.record.filename}:{self.record.lineno}@{self.record.funcName}",
+            f"</div></td>",
+
+            f"<td><div style='background-color:{self.bg};color:{self.fg};'>",
+            # f"{stat_w=} {stat_l=}<br>"
+        ]
+        return '\n'.join(out)
+
+    def display_row_body(self) -> str:
+        return f"{str(self.msg)[:80]}"
+
+    @staticmethod
+    def display_row_end() -> str:
+        return "</div></td>"
+
+
+"""
+LogWatcher is a logging handler that can be attached to the logging subsystem to observe
+log messages generated by all threads of the user's application.
+It manages a collection of ThreadLogWatcher objects, one for each thread.
+"""
+
+
+class LogWatcher(logging.Handler):
+    instance: LogWatcher = None
+
+    def __init__(self, *args, **kwargs):
+        """
+        Constructor.
+        :param args: positional arguments passed to logging.Handler
+        :param kwargs: keyword arguments passed to logging.Handler
+        """
+        super().__init__(*args, **kwargs)
+        self.kwargs = kwargs
+        logging.getLogger().addHandler(self)
+        LogWatcher.instance = self
+        self.thread_log_watchers: dict[int, ThreadLogWatcher] = {}
+        self.display_watchers: list[ThreadLogWatcher] = []
+        self.data_event = threading.Event()
+        self.mylock = threading.RLock()
+        self.listlock = threading.RLock()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Emit a record. (record is recorded to queue)
+        :param record:
+        :return:
+        """
+        if record.name == 'werkzeug':
+            return
+        with self.mylock:
+            self.data_event.set()
+
+            thread = record.thread
+            # tname = f"{record.funcName=} {record.threadName=} {record.name=} {record.filename=}"
+            watcher = self.thread_log_watchers.get(thread, None)
+            oflag = record.msg.startswith(LOG_OP_FMT_STRING) if isinstance(record.msg, str) else False
+            op = record.args[0] if (len(record.args) > 0) and oflag else None  # and (record.message == LOGOP)
+
+            # print(f"EMIT {thread} {op=} {type(op)=} {record.getMessage()} {watcher=} {tname=} {oflag=}")
+            # On termination of a thread, remove the old watcher from the dictionary (but not the list of display watchers).
+            if watcher is not None and (op in [LogOps.NEW_THREAD, LogOps.THREAD_EXIT]):
+                self.thread_log_watchers.pop(thread)
+                watcher.terminated(op)
+                return
+
+            # dont create a watcher for EXIT ops
+            if op in [LogOps.NEW_THREAD, LogOps.THREAD_EXIT]:
+                return
+
+            # if there is no watcher for the thread, create one and add to dictionary and list of display watchers.
+            if watcher is None:
+                watcher = ThreadLogWatcher(record)
+                self.thread_log_watchers[thread] = watcher
+                self.display_watchers.append(watcher)
+
+            if op is None:
+                watcher.process_log_record(record)
+            else:
+                watcher.process_log_op(op, record, *record.args)
+
+    def prepare_display_list(self) -> list[ThreadLogWatcher]:
+        # wait up to 1 second for data to arrive.
+        # self.data_event.wait(timeout=0.5)
+        self.bring_out_your_dead()
+        watchers = self.display_watchers.copy()
+        if len(watchers) > 30:
+            watchers = [watcher for watcher in watchers if watcher.live]
+        return watchers
+
+    def bring_out_your_dead(self, delay: float = 5):
+        # print(f"Bringing out your dead before lock {delay=}")
+        with self.listlock:
+            # print(f"Bringing out your dead inside lock {delay=}")
+            self.data_event.clear()
+
+            now = time()
+            dead_watchers = list([watcher for watcher in self.display_watchers if watcher.time_dead(now) >= delay])
+            for watcher in dead_watchers:
+                self.display_watchers.remove(watcher)
+
+
+"""
+The bridge object connects the user application and flask application.
+All three are expected to be singletons.
+"""
+
+
+class Bridge:
+    instance: Bridge = None
+
+    def __init__(self,
+                 user_callable: Callable[[], None],
+                 flask_app: Flask,
+                 browser: bool = True,
+                 title: str = "Log2Web",
+                 headertext: str = "Data from threads",
+                 address: str = "0.0.0.0",
+                 port: int = 8080,
+                 terminate_callback: Callable[[], None] = None,
+                 ) -> None:
+        self.user_callable = user_callable
+        self.address = address
+        self.port = port
+        self.flask_app = flask_app
+        self.user_thread = Thread(target=self._run_user_in_thread, name="USER_MAIN")
+        self.terminate_callback = terminate_callback
+        Bridge.instance = self
+        self.log_watcher = LogWatcher()
+        self.browser = browser
+
+        self.title = title
+        self.headertext = headertext
+
+    """
+    The run method swaps control of the main thread to the flask application.
+    The user application starts in the main thread. Flask must run in the main thread.
+    A second thread is created to run the user_callable provided in the constructor.
+    This method does not return until the flask application exits.
+    """
+
+    def run(self):
+        self.user_thread.start()
+        self.flask_app.run(host=self.address, port=self.port)
+
+    def _run_user_in_thread(self):
+        """
+        Runs the user callable in a separate thread.
+        On completion, raises a signal to the main thread which is WebGUI to shut down.
+        :return:
+        """
+        try:
+            if self.browser:
+                # noinspection HttpUrlsUsage
+                webbrowser.open(f"http://{self.address}:{self.port}")
+            logging.getLogger().info("starting user callable")
+            self.user_callable()
+            logging.getLogger().info("user callable completed")
+            sleep(4)
+        except Exception as e:
+            logging.getLogger().exception(e)
+        finally:
+            if self.terminate_callback is not None:
+                logging.getLogger().info("Calling terminate callback")
+                try:
+                    self.terminate_callback()
+                except Exception as e:
+                    logging.getLogger().exception(e)
+            logging.getLogger().info("GUI Shutdown")
+            sleep(1)
+            signal.raise_signal(2)
+
+if __name__ == "__main__":
+    print("This module does not run as a standalone program.")

libsrg_log2web/LoggerGUIProxy.py

@@ -0,0 +1,77 @@
+# libsrg (Code and Documentation) is published under an MIT License
+# Copyright (c) 2023,2024 Steven Goncalo
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# 2024 Steven Goncalo
+import logging
+from enum import Enum
+
+
+class LogOps(Enum):
+    NEW_THREAD = 1
+    THREAD_EXIT = 2
+    FG_COLOR = 3
+    BG_COLOR = 4
+
+
+LOG_OP_FMT_STRING = "LOG_OP_FMT_STRING %s"
+
+
+def _send_log_op(op: LogOps, *args, logr=None):
+    fmt = LOG_OP_FMT_STRING
+    fmt += " %s" * len(args)
+    if not logr:
+        logr = logging.getLogger("LoggerGUIProxy")
+    # print(f"send op {op=} {args=} {fmt=}")
+    stacklevel = 2
+    logr.info(fmt, op, stacklevel=stacklevel, *args)
+
+
+class LoggerGUIProxy:
+    """
+    LoggerGUIProxy provides several methods to control the LoggerGUI via calls to logging.
+    """
+
+    @classmethod
+    def gui_new_line(cls, logr=None):
+        """
+        Schedule the GUI line item for this thread to be deleted and disassociate it with this thread.
+        If subsequent logging occurs from the same thread, a new GUI line is created.
+        """
+        _send_log_op(LogOps.NEW_THREAD, logr=logr)
+
+    @classmethod
+    def gui_freeze_line(cls, logr=None):
+        """
+        Freeze the current contents of the GUI line for this thread.
+        Do not schedule the GUI line item for this thread to be deleted but disassociate it with this thread.
+        If subsequent logging occurs from the same thread, a new GUI line is created.
+        """
+        _send_log_op(LogOps.THREAD_EXIT, logr=logr)
+
+    @classmethod
+    def gui_end_line(cls, logr=None):
+        """
+        Freeze the current contents of the GUI line for this thread.
+        Do not schedule the GUI line item for this thread to be deleted but disassociate it with this thread.
+        If subsequent logging occurs from the same thread, a new GUI line is created.
+        """
+        _send_log_op(LogOps.THREAD_EXIT, logr=logr)
+
+    @classmethod
+    def gui_configure(cls, logr=None, **kwargs):
+        """
+        Send one or more logs to set configuration values for the GUI line associated with this thread.
+        Each log sent is a single name/value pair.
+        """
+        if "background" in kwargs:
+            _send_log_op(LogOps.BG_COLOR, kwargs["background"], logr=logr)
+        if "foreground" in kwargs:
+            _send_log_op(LogOps.FG_COLOR, kwargs["foreground"], logr=logr)
+
+    @classmethod
+    def gui_set_colors(cls, logr=None, foreground=None, background=None, ):
+        if foreground:
+            _send_log_op(LogOps.FG_COLOR, foreground, logr=logr)
+        if background:
+            _send_log_op(LogOps.BG_COLOR, background, logr=logr)

libsrg_log2web/static/style.css

@@ -0,0 +1,8 @@
+table.status {
+    border: 1px solid black;
+}
+
+tr.header {
+    background-color: black;
+    color: cyan;
+}

libsrg_log2web/templates/status.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="refresh" content="{{ delay }}">
+    <link href="../static/style.css" rel="stylesheet" type="text/css">
+    <title>{{title}}</title>
+</head>
+<body>
+{{headertext}}
+    <table class="status">
+        <tr class="header">
+            <th>Thread</th>
+            <th>Net Status</th>
+            <th>Latest Status</th>
+            <th>Location</th>
+            <th>Message</th>
+        </tr>
+        {% for watcher in watchers %}
+            <tr>
+            {{ watcher.display_row_start()|safe }}
+            {{ watcher.display_row_body() }}
+            {{ watcher.display_row_end()|safe }}
+
+            </tr>
+        {% endfor %}
+    </table>
+
+</body>
+</html>

libsrg_log2web-1.0.7.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: libsrg_log2web
+Version: 1.0.7
+Summary: Multithreded logging to webpage
+Author-email: Steve Goncalo <steven@goncalo.us>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.14
+Requires-Dist: flask>=3.1.2
+Requires-Dist: libsrg>=6.0.4

libsrg_log2web-1.0.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+libsrg_log2web/Demo.py,sha256=bzPkIb-0mCuooME8q5pdUZzUn-Gc9_naMRo-8wdukBE,2224
+libsrg_log2web/FlaskApp.py,sha256=x_xBZbRR5Al7hnqlp1cy5arC0Ba_3a-K8_eL56mx9OI,1027
+libsrg_log2web/Log2Web.py,sha256=gOLqbDD103NNj3A_LpwKGEUb4fE3hrIv1F2sZrJTNaI,10837
+libsrg_log2web/LoggerGUIProxy.py,sha256=_v7vScn1DEF9BT8XCuMTtQ_0u3yMjtmLlq7RiCOdI_k,2714
+libsrg_log2web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libsrg_log2web/static/style.css,sha256=GBktqyouX908PaeRx8BreKqrT9aAMEUQx08zSXV4UBU,106
+libsrg_log2web/templates/status.html,sha256=ZM8a1x95JukuvGVMqp8IiBkwxXmzeLYGJXAZV42staQ,743
+libsrg_log2web-1.0.7.dist-info/METADATA,sha256=u3b7zp8M0HAKBr2pd-i1ogWXmnGbNjaXI7_jsAkSA_U,521
+libsrg_log2web-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+libsrg_log2web-1.0.7.dist-info/top_level.txt,sha256=1lhFTpg88gjbyp67E4jaEF4qOdgh4nS7XerT50wmelM,15
+libsrg_log2web-1.0.7.dist-info/RECORD,,

libsrg_log2web-1.0.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

libsrg_log2web-1.0.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+libsrg_log2web