logmachine 2.1.0__tar.gz → 2.2.0__tar.gz

{logmachine-2.1.0/logmachine.egg-info → logmachine-2.2.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: logmachine
-Version: 2.1.0
+Version: 2.2.0
 Summary: Collaborative, beautiful logging system for distributed developers
 Author-email: Mugabo Gusenga <mugabo@bufferpunk.com>
 Project-URL: Homepage, https://logmachine.bufferpunk.com
-Project-URL: Documentation, https://github.com/Scion-Kin/logmachine
-Project-URL: Source, https://github.com/Scion-Kin/logmachine
-Project-URL: Tracker, https://github.com/Scion-Kin/logmachine/issues
+Project-URL: Documentation, https://github.com/logmachine/python
+Project-URL: Source, https://github.com/logmachine/python
+Project-URL: Tracker, https://github.com/logmachine/python/issues
 Keywords: logging,devtools,collaborative,open source,cli,json,ansi
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -16,7 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# 🧠 logmachine 2.1.0
+# 🧠 LogMachine
 
 > Collaborative, beautiful logging system for distributed developers
 
@@ -50,11 +50,11 @@ pip install logmachine
 ### Basic Setup
 
 ```python
-from logmachine import ContribLog
+from logmachine import LogMachine
 
 # Create a simple logger without central logging
-# Providing a noon-empty string initializes the logger with that name, else the root logger is used to collect every single log in the python process.
-logger = ContribLog("myapp", debug_level=1)
+# Providing a non-empty string initializes the logger with that name, else the root logger is used to collect every single log in the python process.
+logger = LogMachine("myapp", debug_level=1)
 
 logger.info("Hello, world!")
 logger.error("An error occurred!")
@@ -65,6 +65,17 @@ logger.warning("This is a warning message.")
 
 ### With Central Logging (HTTP or Socket.IO)
 
+You can use the default logger with central logging pointing to "https://logmachine.bufferpunk.com"  
+
+```python
+from logmachine import default_logger
+logger = default_logger()
+logger.info("This log is sent to the LogMachine default central server!")
+```
+
+This is the default central logging server for logmachine, and you can create your own room there for free.
+To use your own central logging server, provide the configuration as shown below:
+
 ```python
 logger_config = {
     "url": "https://logmachine.bufferpunk.com",  # Base server URL
@@ -74,7 +85,7 @@ logger_config = {
     "socketio": True,                    # Set False to use HTTP
     "socketio_path": "/api/socket.io/"  # Optional
 }
-logger = ContribLog("with_central", debug_level=0, central=logger_config, socketio=True)
+logger = LogMachine("with_central", debug_level=0, central=logger_config, socketio=True)
 logger.success("Central logging is working!")
 ```
 
@@ -105,8 +116,9 @@ Sample (terminal):
 ### Add Your Own Log Level
 
 ```python
-log.new_level("CRITICAL_HACK", 60)
-log.critical_hack("Zero day found!")
+logger.new_level("CRITICAL_HACK", 60)
+logger.new_level("CRITICAL_HACK", 60, color="\033[38;5;13m")  # Optional color... does your girlfriend love pink? Maybe you should be in a relationship with your terminal.
+logger.critical_hack("Zero day found!")
 ```
 
 ---
@@ -115,6 +127,9 @@ log.critical_hack("Zero day found!")
 
 ### Convert Logs to JSON
 
+This is useful for sending logs to web dashboards or log collectors that expect JSON.
+It reads the your log files, parses the log entries, and outputs them as JSON objects.
+
 ```python
 json_logs = log.jsonifier()
 for entry in json_logs:

logmachine-2.1.0/PKG-INFO → logmachine-2.2.0/README.md

@@ -1,22 +1,4 @@
-Metadata-Version: 2.4
-Name: logmachine
-Version: 2.1.0
-Summary: Collaborative, beautiful logging system for distributed developers
-Author-email: Mugabo Gusenga <mugabo@bufferpunk.com>
-Project-URL: Homepage, https://logmachine.bufferpunk.com
-Project-URL: Documentation, https://github.com/Scion-Kin/logmachine
-Project-URL: Source, https://github.com/Scion-Kin/logmachine
-Project-URL: Tracker, https://github.com/Scion-Kin/logmachine/issues
-Keywords: logging,devtools,collaborative,open source,cli,json,ansi
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# 🧠 logmachine 2.1.0
+# 🧠 LogMachine
 
 > Collaborative, beautiful logging system for distributed developers
 
@@ -50,11 +32,11 @@ pip install logmachine
 ### Basic Setup
 
 ```python
-from logmachine import ContribLog
+from logmachine import LogMachine
 
 # Create a simple logger without central logging
-# Providing a noon-empty string initializes the logger with that name, else the root logger is used to collect every single log in the python process.
-logger = ContribLog("myapp", debug_level=1)
+# Providing a non-empty string initializes the logger with that name, else the root logger is used to collect every single log in the python process.
+logger = LogMachine("myapp", debug_level=1)
 
 logger.info("Hello, world!")
 logger.error("An error occurred!")
@@ -65,6 +47,17 @@ logger.warning("This is a warning message.")
 
 ### With Central Logging (HTTP or Socket.IO)
 
+You can use the default logger with central logging pointing to "https://logmachine.bufferpunk.com"  
+
+```python
+from logmachine import default_logger
+logger = default_logger()
+logger.info("This log is sent to the LogMachine default central server!")
+```
+
+This is the default central logging server for logmachine, and you can create your own room there for free.
+To use your own central logging server, provide the configuration as shown below:
+
 ```python
 logger_config = {
     "url": "https://logmachine.bufferpunk.com",  # Base server URL
@@ -74,7 +67,7 @@ logger_config = {
     "socketio": True,                    # Set False to use HTTP
     "socketio_path": "/api/socket.io/"  # Optional
 }
-logger = ContribLog("with_central", debug_level=0, central=logger_config, socketio=True)
+logger = LogMachine("with_central", debug_level=0, central=logger_config, socketio=True)
 logger.success("Central logging is working!")
 ```
 
@@ -105,8 +98,9 @@ Sample (terminal):
 ### Add Your Own Log Level
 
 ```python
-log.new_level("CRITICAL_HACK", 60)
-log.critical_hack("Zero day found!")
+logger.new_level("CRITICAL_HACK", 60)
+logger.new_level("CRITICAL_HACK", 60, color="\033[38;5;13m")  # Optional color... does your girlfriend love pink? Maybe you should be in a relationship with your terminal.
+logger.critical_hack("Zero day found!")
 ```
 
 ---
@@ -115,6 +109,9 @@ log.critical_hack("Zero day found!")
 
 ### Convert Logs to JSON
 
+This is useful for sending logs to web dashboards or log collectors that expect JSON.
+It reads the your log files, parses the log entries, and outputs them as JSON objects.
+
 ```python
 json_logs = log.jsonifier()
 for entry in json_logs:

logmachine-2.2.0/logmachine/__init__.py

@@ -0,0 +1 @@
+from .main import LogMachine, default_logger

{logmachine-2.1.0 → logmachine-2.2.0}/logmachine/main.py

@@ -1,9 +1,13 @@
+import atexit
 import os
 import re
 import json
 import logging
 import requests
 import socketio
+import queue
+from logging.handlers import QueueHandler, QueueListener
+
 
 def get_login():
     """
@@ -11,12 +15,17 @@ def get_login():
     :return: The login name of the current user.
     """
     try:
-        return os.getlogin()
+        if not os.path.exists(os.path.expanduser("~/.cl_username")):
+            return os.getlogin()
+        else:
+            with open(os.path.expanduser("~/.cl_username"), 'r') as f:
+                os.environ['CL_USERNAME'] = f.read().strip()
+            return os.environ['CL_USERNAME']
     except Exception:
         return os.environ.get('USER', 'unknown')
 
 
-class RequestsTransporter(logging.StreamHandler):
+class HTTPTransporter(logging.StreamHandler):
     """
     A class to handle the transport of log messages using HTTP requests.
     This class sends log messages to a central server via HTTP POST requests.
@@ -36,22 +45,19 @@ class RequestsTransporter(logging.StreamHandler):
         try:
             msg = self.format(record)
             super().emit(record)
-            if self.central:
-                if not self.central.get('room'):
-                    raise ValueError("""
-                                     Central configuration must include 'room' for log transport.
-                                        Example: {'url': 'http://central-server/api/logs', 'room': 'my_organization_name'}
-                                     """)
-
-                log_data = self.parse_log(msg)
-                if log_data:
-                    response = requests.post(
-                        f"{self.central.get('url', '') + self.central.get('endpoint', '/api/logs')}?room={self.central.get('room', '')}",
-                        json=log_data,
-                        headers={"Content-Type": "application/json", **self.central.get('headers', {})}
-                    )
-                    if response.status_code != 200:
-                        raise Exception(f"Failed to send log to central: {response.text}")
+            if not self.central or not self.central.get('room'):
+                raise ValueError("""Central configuration must include 'room' for log transport.
+                    Example: {'url': 'http://central-server/api/logs', 'room': 'my_organization_name'}""")
+
+            log_data = self.parse_log(msg)
+            if log_data:
+                response = requests.post(
+                    f"{self.central.get('url', '') + self.central.get('endpoint', '/api/logs')}?room={self.central.get('room', '')}",
+                    json=log_data,
+                    headers={"Content-Type": "application/json", **self.central.get('headers', {})}
+                )
+                if response.status_code != 200:
+                    raise Exception(f"Failed to send log to central: {response.text}")
 
         except Exception:
             self.handleError(record)
@@ -90,57 +96,67 @@ class SocketIOTransporter(logging.StreamHandler):
 
 
 class CustomFormatter(logging.Formatter):
-    COLORS = {
-        'DEBUG': '\x1b[36m',
-        'INFO': '\x1b[34m',
-        'WARNING': '\x1b[33m',
-        'ERROR': '\x1b[31m',
-        'SUCCESS': '\x1b[32m'
-    }
-    RESET = '\x1b[0m'
-    BOLD = '\x1b[1m'
-    LEVEL_FORMATS = {
-        'DEBUG': BOLD + '[ DEBUG ]' + RESET,
-        'INFO': BOLD + '[ INFO ]' + RESET,
-        'WARNING': BOLD + '[ WARNING ]' + RESET,
-        'ERROR': BOLD + '[ ERROR ]' + RESET,
-        'SUCCESS': BOLD + '[ SUCCESS ]' + RESET
-    }
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.colors = {
+            'DEBUG': '\x1b[36m',
+            'INFO': '\x1b[34m',
+            'WARNING': '\x1b[33m',
+            'ERROR': '\x1b[31m',
+            'SUCCESS': '\x1b[32m'
+        }
+        self.reset = '\x1b[0m'
+        self.bold = '\x1b[1m'
+        self.level_formats = {
+            'DEBUG': self.bold + '[ DEBUG ]' + self.reset,
+            'INFO': self.bold + '[ INFO ]' + self.reset,
+            'WARNING': self.bold + '[ WARNING ]' + self.reset,
+            'ERROR': self.bold + '[ ERROR ]' + self.reset,
+            'SUCCESS': self.bold + '[ SUCCESS ]' + self.reset
+        }
+
+    def set_color(self, levelname: str, color_code: str):
+        """
+        Set a custom color for a specific log level.
+        :param levelname: The name of the log level (e.g., 'DEBUG', 'INFO').
+        :param color_code: The ANSI color code to use for the specified log level.
+        """
+        self.colors[levelname] = color_code
+        self.level_formats[levelname] = f"{self.bold}[ {levelname} ]{self.reset}"
 
     def format(self, record) -> str:
         username = os.environ.get('CL_USERNAME') or get_login()
 
         levelname = record.levelname
-        color = self.COLORS.get(levelname, '')
-        level_fmt = self.LEVEL_FORMATS.get(levelname, f'{levelname}')
-        level_fmt = f"{color}{level_fmt}{self.RESET}"
+        color = self.colors.get(levelname, '')
+        level_fmt = self.level_formats.get(levelname, f'{levelname}')
+        level_fmt = f"{color}{level_fmt}{self.reset}"
         record.asctime = self.formatTime(record, self.datefmt)
         module_file = record.pathname
         parent_dir = os.path.basename(os.path.dirname(record.pathname)) if module_file != '<stdin>' else 'stdin'
 
-        return f"""{self.COLORS.get('DEBUG')}({username}{self.RESET} @ {self.COLORS.get('WARNING') + parent_dir + self.RESET}) 🤌 CL Timing: {color}[ {record.asctime} ]{self.RESET}
+        return f"""{self.colors.get('DEBUG')}({username}{self.reset} @ {self.colors.get('WARNING') + parent_dir + self.reset}) 🤌 CL Timing: {color}[ {record.asctime} ]{self.reset}
 {level_fmt} {record.getMessage()}
 🏁"""
 
-class ContribLog(logging.Logger):
-    SUCCESS = 25
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, level=logging.DEBUG)
-        logging.addLevelName(self.SUCCESS, "SUCCESS")
+class LogMachine(logging.Logger):
+    def __init__(self, name="", *args, **kwargs) -> None:
+        super().__init__(name, *args, level=int(kwargs.get('debug_level', 0)))
+        logging.addLevelName(25, "SUCCESS")
         self.log_file = kwargs.get('log_file', 'logs.log')
         self.error_file = kwargs.get('error_file', 'errors.log')
         self.debug_level = int(kwargs.get('debug_level', 0))
         self.verbose = kwargs.get('verbose', False)
         self.central = kwargs.get('central', None)
-        self.setLevel(logging.DEBUG)
+        self.queue = queue.Queue()
 
         # Remove existing handlers
-        self.handlers = []
+        for h in self.handlers[:]:
+            self.removeHandler(h)
 
         # File handlers
         fh = logging.FileHandler(self.log_file)
-        fh.setLevel(logging.DEBUG)
+        fh.setLevel(self.debug_level)
         eh = logging.FileHandler(self.error_file)
         eh.setLevel(logging.ERROR)
 
@@ -148,7 +164,7 @@ class ContribLog(logging.Logger):
         if self.central:
             """
                The central uses usernames to group logs.
-               OS usernames are used to identify the use, meaning names can clash.
+               OS usernames are used to identify the user, meaning names can clash.
                Therefore, we avoid a user having to define a username, rather, ask the central server to provide it.
                After getting the username, we store it in the user's home directory in a file named `.cl_username`.
                This way, the user can change it at any time, and it will be used in all future logs without needing to request it again.
@@ -158,42 +174,37 @@ class ContribLog(logging.Logger):
                     login = get_login()
                     response = requests.get(f"{self.central.get('url', '')}/api/get_username?base={login}")
                     if response.status_code == 200:
-                        os.environ['CL_USERNAME'] = response.json().get('username', 'unknown') # Unknown will probably never be reached, but it's a fallback.
+                        os.environ['CL_USERNAME'] = response.json().get('username') or 'unknown' # Unknown will probably never be reached, but it's a fallback.
                         if os.environ.get('CL_USERNAME') != 'unknown':
                             with open(os.path.expanduser("~/.cl_username"), 'w') as f:
                                 f.write(os.environ['CL_USERNAME'])
                     else:
                         os.environ['CL_USERNAME'] = 'unknown'
-                except Exception as e:
+                except Exception:
                     os.environ['CL_USERNAME'] = 'unknown'
             else:
-                with open(os.path.expanduser("~/.cl_username"), 'r') as f:
-                    os.environ['CL_USERNAME'] = f.read().strip()
+                get_login()
 
             if not kwargs.get('attached', False) and not self.central.get('socketio', False):
-                ch = RequestsTransporter(log_parser=self.parse_log, central=self.central)
+                ch = HTTPTransporter(log_parser=self.parse_log, central=self.central)
             else:
                 ch = SocketIOTransporter(log_parser=self.parse_log, central=self.central)
-
         else:
             ch = logging.StreamHandler()
 
         ch.setLevel(logging.DEBUG)
 
-        formatter = CustomFormatter('%(asctime)s %(levelname)s %(message)s', datefmt='%Y-%m-%dT%H:%M:%S%z')
-        fh.setFormatter(formatter)
-        eh.setFormatter(formatter)
-        ch.setFormatter(formatter)
-
-        self.addHandler(fh)
-        self.addHandler(eh)
-        self.addHandler(ch)
+        self.formatter = CustomFormatter('%(asctime)s %(levelname)s %(message)s', datefmt='%Y-%m-%dT%H:%M:%S%z')
+        fh.setFormatter(self.formatter)
+        eh.setFormatter(self.formatter)
+        ch.setFormatter(self.formatter)
+        self.addHandler(QueueHandler(self.queue))
 
         # Filter console output based on debug_level
         class DebugLevelFilter(logging.Filter):
             def __init__(self, debug_level):
                 super().__init__()
-                self.debug_level = int(debug_level)
+                self.debug_level = debug_level
 
             def filter(self, record):
                 if self.debug_level == 0:
@@ -212,12 +223,22 @@ class ContribLog(logging.Logger):
                 return record.levelname in allowed
 
         ch.addFilter(DebugLevelFilter(self.debug_level if not self.verbose else 0))
+        self.listener = QueueListener(self.queue, fh, eh, ch)
+        self.listener.start()
+        atexit.register(self.listener.stop)
+        self.info("LogMachine initialized with debug level {} with{}".format(
+                self.debug_level,
+                self.central and
+                f" central logging to {self.central.get('url', '')}" or
+                "out central logging"
+            )
+        )
 
     def success(self, msg, *args, **kwargs) -> None:
-        if self.isEnabledFor(self.SUCCESS):
-            self._log(self.SUCCESS, msg, args, stacklevel=2, **kwargs)
+        if self.isEnabledFor(25):
+            self._log(25, msg, args, stacklevel=2, **kwargs)
 
-    def new_level(self, level_name: str, level_num: int):
+    def new_level(self, level_name: str, level_num: int, ansi_color="\x1b[37m") -> None:
         """
         Dynamically add a new logging level.
         :param level_name: Name of the new logging level.
@@ -228,8 +249,9 @@ class ContribLog(logging.Logger):
             logging.addLevelName(level_num, level_name)
             setattr(self, level_name.lower(), lambda msg, *args, **kwargs: self._log(level_num, msg, args, stacklevel=2, **kwargs))
             self.setLevel(min(self.level, level_num))  # Ensure the logger's level is set appropriately
+            self.formatter.set_color(level_name, ansi_color) # Add color formatting for the new level
 
-    def parse_log(self, log_text) -> dict:
+    def parse_log(self, log_text) -> dict | None:
         log_text = log_text.strip()
         ansi_escape = re.compile(r'\x1b\[[0-9;]*m')
         end_escape = re.compile(r'🏁')
@@ -240,7 +262,7 @@ class ContribLog(logging.Logger):
         header_match = re.search(header_pattern, clean)
 
         if not header_match:
-            return None
+            return
 
         user, module, timestamp = header_match.groups()
         lines = clean.splitlines()
@@ -257,7 +279,7 @@ class ContribLog(logging.Logger):
             "timestamp": timestamp,
             "message": end_escape.sub('', message).strip()
         }
-    
+
     def jsonifier(self) -> list:
         """
         Reads the log file and returns a list of JSON objects representing each log entry.
@@ -278,4 +300,12 @@ class ContribLog(logging.Logger):
         return log_entries
 
 
-logging.setLoggerClass(ContribLog)
+def default_logger():
+    return LogMachine('default_logger', debug_level=0, verbose=False, central={
+        'url': 'https://logmachine.bufferpunk.com',
+        'room': f'{get_login()}_logs',
+        'headers': {}
+    })
+
+
+logging.setLoggerClass(LogMachine)

logmachine-2.1.0/README.md → logmachine-2.2.0/logmachine.egg-info/PKG-INFO

@@ -1,4 +1,22 @@
-# 🧠 logmachine 2.1.0
+Metadata-Version: 2.4
+Name: logmachine
+Version: 2.2.0
+Summary: Collaborative, beautiful logging system for distributed developers
+Author-email: Mugabo Gusenga <mugabo@bufferpunk.com>
+Project-URL: Homepage, https://logmachine.bufferpunk.com
+Project-URL: Documentation, https://github.com/logmachine/python
+Project-URL: Source, https://github.com/logmachine/python
+Project-URL: Tracker, https://github.com/logmachine/python/issues
+Keywords: logging,devtools,collaborative,open source,cli,json,ansi
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🧠 LogMachine
 
 > Collaborative, beautiful logging system for distributed developers
 
@@ -32,11 +50,11 @@ pip install logmachine
 ### Basic Setup
 
 ```python
-from logmachine import ContribLog
+from logmachine import LogMachine
 
 # Create a simple logger without central logging
-# Providing a noon-empty string initializes the logger with that name, else the root logger is used to collect every single log in the python process.
-logger = ContribLog("myapp", debug_level=1)
+# Providing a non-empty string initializes the logger with that name, else the root logger is used to collect every single log in the python process.
+logger = LogMachine("myapp", debug_level=1)
 
 logger.info("Hello, world!")
 logger.error("An error occurred!")
@@ -47,6 +65,17 @@ logger.warning("This is a warning message.")
 
 ### With Central Logging (HTTP or Socket.IO)
 
+You can use the default logger with central logging pointing to "https://logmachine.bufferpunk.com"  
+
+```python
+from logmachine import default_logger
+logger = default_logger()
+logger.info("This log is sent to the LogMachine default central server!")
+```
+
+This is the default central logging server for logmachine, and you can create your own room there for free.
+To use your own central logging server, provide the configuration as shown below:
+
 ```python
 logger_config = {
     "url": "https://logmachine.bufferpunk.com",  # Base server URL
@@ -56,7 +85,7 @@ logger_config = {
     "socketio": True,                    # Set False to use HTTP
     "socketio_path": "/api/socket.io/"  # Optional
 }
-logger = ContribLog("with_central", debug_level=0, central=logger_config, socketio=True)
+logger = LogMachine("with_central", debug_level=0, central=logger_config, socketio=True)
 logger.success("Central logging is working!")
 ```
 
@@ -87,8 +116,9 @@ Sample (terminal):
 ### Add Your Own Log Level
 
 ```python
-log.new_level("CRITICAL_HACK", 60)
-log.critical_hack("Zero day found!")
+logger.new_level("CRITICAL_HACK", 60)
+logger.new_level("CRITICAL_HACK", 60, color="\033[38;5;13m")  # Optional color... does your girlfriend love pink? Maybe you should be in a relationship with your terminal.
+logger.critical_hack("Zero day found!")
 ```
 
 ---
@@ -97,6 +127,9 @@ log.critical_hack("Zero day found!")
 
 ### Convert Logs to JSON
 
+This is useful for sending logs to web dashboards or log collectors that expect JSON.
+It reads the your log files, parses the log entries, and outputs them as JSON objects.
+
 ```python
 json_logs = log.jsonifier()
 for entry in json_logs:

{logmachine-2.1.0 → logmachine-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "logmachine"
-version = "2.1.0"
+version = "2.2.0"
 description = "Collaborative, beautiful logging system for distributed developers"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -17,9 +17,9 @@ classifiers = [
 
 [project.urls]
 Homepage = "https://logmachine.bufferpunk.com"
-Documentation = "https://github.com/Scion-Kin/logmachine"
-Source = "https://github.com/Scion-Kin/logmachine"
-Tracker = "https://github.com/Scion-Kin/logmachine/issues"
+Documentation = "https://github.com/logmachine/python"
+Source = "https://github.com/logmachine/python"
+Tracker = "https://github.com/logmachine/python/issues"
 
 [build-system]
 requires = ["setuptools>=61.0", "websocket-client", "python-socketio", "requests"]

logmachine-2.1.0/logmachine/__init__.py

@@ -1 +0,0 @@
-from .main import ContribLog