Created 'murfey.util.logging' to store LogFilter and HTTPSHandler classes in; removed CustomHandler

Author: tieneupin

src/murfey/instrument_server/__init__.py

@@ -25,10 +25,9 @@ def start_instrument_server():
     from rich.logging import RichHandler
 
     import murfey
-    from murfey.client.customlogging import HTTPSHandler
-    from murfey.util import LogFilter
     from murfey.util.api import url_path_for
     from murfey.util.client import read_config
+    from murfey.util.logging import HTTPSHandler, LogFilter
 
     parser = argparse.ArgumentParser(description="Start the Murfey server")
     parser.add_argument(

src/murfey/server/run.py

@@ -16,8 +16,8 @@
 import murfey.server
 from murfey.server.feedback import feedback_listen
 from murfey.server.ispyb import TransportManager
-from murfey.util import LogFilter
 from murfey.util.config import get_microscope, get_security_config
+from murfey.util.logging import LogFilter
 
 logger = logging.getLogger("murfey.server.run")
 

src/murfey/util/__init__.py

@@ -96,42 +96,6 @@ def wait(self):
             self.thread.join()
 
 
-class LogFilter(logging.Filter):
-    """A filter to limit messages going to Graylog"""
-
-    def __repr__(self):
-        return "<murfey.server.LogFilter>"
-
-    def __init__(self):
-        super().__init__()
-        self._filter_levels = {
-            "murfey": logging.DEBUG,
-            "ispyb": logging.DEBUG,
-            "zocalo": logging.DEBUG,
-            "uvicorn": logging.INFO,
-            "fastapi": logging.INFO,
-            "starlette": logging.INFO,
-            "sqlalchemy": logging.INFO,
-        }
-
-    @staticmethod
-    def install() -> LogFilter:
-        logfilter = LogFilter()
-        root_logger = logging.getLogger()
-        for handler in root_logger.handlers:
-            handler.addFilter(logfilter)
-        return logfilter
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        logger_name = record.name
-        while True:
-            if logger_name in self._filter_levels:
-                return record.levelno >= self._filter_levels[logger_name]
-            if "." not in logger_name:
-                return False
-            logger_name = logger_name.rsplit(".", maxsplit=1)[0]
-
-
 def safe_run(
     func: Callable,
     args: list | tuple = [],

src/murfey/client/customlogging.py src/murfey/util/logging.pysrc/murfey/client/customlogging.py renamed to src/murfey/util/logging.py

@@ -9,26 +9,40 @@
 import requests
 
 
-class CustomHandler(logging.Handler):
-    def __init__(self, callback):
-        """Set up a handler instance, record the callback function."""
-        super().__init__()
-        self._callback = callback
+class LogFilter(logging.Filter):
+    """A filter to limit messages going to Graylog"""
 
-    def prepare(self, record):
-        self.format(record)
-        record_dict = record.__dict__
-        record_dict["type"] = "log"
-        try:
-            return json.dumps(record_dict)
-        except TypeError:
-            return json.dumps({str(k): str(v) for k, v in record_dict.items()})
+    def __repr__(self):
+        return "<murfey.server.LogFilter>"
 
-    def emit(self, record):
-        try:
-            self._callback(self.prepare(record))
-        except Exception:
-            self.handleError(record)
+    def __init__(self):
+        super().__init__()
+        self._filter_levels = {
+            "murfey": logging.DEBUG,
+            "ispyb": logging.DEBUG,
+            "zocalo": logging.DEBUG,
+            "uvicorn": logging.INFO,
+            "fastapi": logging.INFO,
+            "starlette": logging.INFO,
+            "sqlalchemy": logging.INFO,
+        }
+
+    @staticmethod
+    def install() -> LogFilter:
+        logfilter = LogFilter()
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers:
+            handler.addFilter(logfilter)
+        return logfilter
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        logger_name = record.name
+        while True:
+            if logger_name in self._filter_levels:
+                return record.levelno >= self._filter_levels[logger_name]
+            if "." not in logger_name:
+                return False
+            logger_name = logger_name.rsplit(".", maxsplit=1)[0]
 
 
 class HTTPSHandler(logging.Handler):
@@ -89,9 +103,7 @@ def format_record(self, record: logging.LogRecord):
 
     def _worker(self):
         """
-        Worker function that sends batches of logs to the URL endpoint specified,
-        with logic to adjust how frequently it should batch and send logs depending
-        on rate of incoming traffic
+        The worker function when the handler is run as a thread.
         """
 
         batch: list[str] = []
@@ -130,9 +142,6 @@ def _worker(self):
             self._send_batch(batch)
 
     def _send_batch(self, batch: list[str]):
-        """
-        Submits the list of stringified log records to the URL endpoint specified.
-        """
         for attempt in range(1, self.max_retry + 1):
             try:
                 response = requests.post(self.endpoint_url, json=batch, timeout=5)