aprsd 3.3.4__py2.py3-none-any.whl → 3.4.0__py2.py3-none-any.whl

aprsd/log/log.py

@@ -6,11 +6,12 @@ import sys
 from loguru import logger
 from oslo_config import cfg
 
-from aprsd import conf
+from aprsd.conf import log as conf_log
 
 
 CONF = cfg.CONF
-LOG = logging.getLogger("APRSD")
+# LOG = logging.getLogger("APRSD")
+LOG = logger
 logging_queue = queue.Queue()
 
 
@@ -38,7 +39,7 @@ def setup_logging(loglevel=None, quiet=False):
     if not loglevel:
         log_level = CONF.logging.log_level
     else:
-        log_level = conf.log.LOG_LEVELS[loglevel]
+        log_level = conf_log.LOG_LEVELS[loglevel]
 
     # intercept everything at the root logger
     logging.root.handlers = [InterceptHandler()]
@@ -53,9 +54,15 @@ def setup_logging(loglevel=None, quiet=False):
         "aprslib.parsing",
         "aprslib.exceptions",
     ]
+    webserver_list = [
+        "werkzeug",
+        "werkzeug._internal",
+        "socketio",
+        "urllib3.connectionpool",
+    ]
 
     # We don't really want to see the aprslib parsing debug output.
-    disable_list = imap_list + aprslib_list
+    disable_list = imap_list + aprslib_list + webserver_list
 
     # remove every other logger's handlers
     # and propagate to root logger
@@ -66,17 +73,29 @@ def setup_logging(loglevel=None, quiet=False):
         else:
             logging.getLogger(name).propagate = True
 
+    if CONF.webchat.disable_url_request_logging:
+        for name in webserver_list:
+            logging.getLogger(name).handlers = []
+            logging.getLogger(name).propagate = True
+            logging.getLogger(name).setLevel(logging.ERROR)
+
     handlers = [
         {
-            "sink": sys.stdout, "serialize": False,
+            "sink": sys.stdout,
+            "serialize": False,
             "format": CONF.logging.logformat,
+            "colorize": True,
+            "level": log_level,
         },
     ]
     if CONF.logging.logfile:
         handlers.append(
             {
-                "sink": CONF.logging.logfile, "serialize": False,
+                "sink": CONF.logging.logfile,
+                "serialize": False,
                 "format": CONF.logging.logformat,
+                "colorize": False,
+                "level": log_level,
             },
         )
 
@@ -90,8 +109,11 @@ def setup_logging(loglevel=None, quiet=False):
             {
                 "sink": qh, "serialize": False,
                 "format": CONF.logging.logformat,
+                "level": log_level,
+                "colorize": False,
             },
         )
 
     # configure loguru
     logger.configure(handlers=handlers)
+    logger.level("DEBUG", color="<fg #BABABA>")

aprsd/main.py

@@ -24,18 +24,17 @@ import datetime
 import importlib.metadata as imp
 from importlib.metadata import version as metadata_version
 import logging
-import os
 import signal
 import sys
 import time
 
 import click
-import click_completion
 from oslo_config import cfg, generator
 
 # local imports here
 import aprsd
-from aprsd import cli_helper, packets, stats, threads, utils
+from aprsd import cli_helper, packets, threads, utils
+from aprsd.stats import collector
 
 
 # setup the global logger
@@ -44,19 +43,6 @@ CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
 flask_enabled = False
-rpc_serv = None
-
-
-def custom_startswith(string, incomplete):
-    """A custom completion match that supports case insensitive matching."""
-    if os.environ.get("_CLICK_COMPLETION_COMMAND_CASE_INSENSITIVE_COMPLETE"):
-        string = string.lower()
-        incomplete = incomplete.lower()
-    return string.startswith(incomplete)
-
-
-click_completion.core.startswith = custom_startswith
-click_completion.init()
 
 
 @click.group(cls=cli_helper.AliasedGroup, context_settings=CONTEXT_SETTINGS)
@@ -96,7 +82,8 @@ def signal_handler(sig, frame):
         packets.PacketTrack().save()
         packets.WatchList().save()
         packets.SeenList().save()
-        LOG.info(stats.APRSDStats())
+        packets.PacketList().save()
+        LOG.info(collector.Collector().collect())
         # signal.signal(signal.SIGTERM, sys.exit(0))
         # sys.exit(0)
 

aprsd/packets/__init__.py

@@ -1,6 +1,7 @@
 from aprsd.packets.core import (  # noqa: F401
-    AckPacket, BeaconPacket, GPSPacket, MessagePacket, MicEPacket, Packet,
-    RejectPacket, StatusPacket, WeatherPacket,
+    AckPacket, BeaconPacket, BulletinPacket, GPSPacket, MessagePacket,
+    MicEPacket, ObjectPacket, Packet, RejectPacket, StatusPacket,
+    ThirdPartyPacket, UnknownPacket, WeatherPacket, factory,
 )
 from aprsd.packets.packet_list import PacketList  # noqa: F401
 from aprsd.packets.seen_list import SeenList  # noqa: F401

aprsd/packets/collector.py

@@ -0,0 +1,56 @@
+import logging
+from typing import Callable, Protocol, runtime_checkable
+
+from aprsd.packets import core
+from aprsd.utils import singleton
+
+
+LOG = logging.getLogger("APRSD")
+
+
+@runtime_checkable
+class PacketMonitor(Protocol):
+    """Protocol for Monitoring packets in some way."""
+
+    def rx(self, packet: type[core.Packet]) -> None:
+        """When we get a packet from the network."""
+        ...
+
+    def tx(self, packet: type[core.Packet]) -> None:
+        """When we send a packet out the network."""
+        ...
+
+
+@singleton
+class PacketCollector:
+    def __init__(self):
+        self.monitors: list[Callable] = []
+
+    def register(self, monitor: Callable) -> None:
+        self.monitors.append(monitor)
+
+    def unregister(self, monitor: Callable) -> None:
+        self.monitors.remove(monitor)
+
+    def rx(self, packet: type[core.Packet]) -> None:
+        for name in self.monitors:
+            cls = name()
+            if isinstance(cls, PacketMonitor):
+                try:
+                    cls.rx(packet)
+                except Exception as e:
+                    LOG.error(f"Error in monitor {name} (rx): {e}")
+
+            else:
+                raise TypeError(f"Monitor {name} is not a PacketMonitor")
+
+    def tx(self, packet: type[core.Packet]) -> None:
+        for name in self.monitors:
+            cls = name()
+            if isinstance(cls, PacketMonitor):
+                try:
+                    cls.tx(packet)
+                except Exception as e:
+                    LOG.error(f"Error in monitor {name} (tx): {e}")
+            else:
+                raise TypeError(f"Monitor {name} is not a PacketMonitor")