logmachine 2.0.0__tar.gz → 2.2.0__tar.gz

logmachine-2.2.0/PKG-INFO

@@ -0,0 +1,195 @@
+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
+
+**logmachine** helps teams log smarter. It’s a fully pluggable logging system that supports colored output, JSON parsing, structured log forwarding via **HTTP or Socket.IO**, and log centralization — all from a standard Python logging interface.
+
+---
+
+## 🚀 Features
+
+- 🔥 **Color-coded terminal logs** (DEBUG, INFO, WARNING, ERROR, SUCCESS)
+- 📤 **Log forwarding** to a central HTTP or Socket.IO server
+- 🪵 **Custom log levels** (add your own with `.new_level(...)`)
+- 👥 **User identity tracking** for team-based logs
+- 🧩 **Pluggable backends**: send logs to a central server or local files
+- 📦 **Simple JSON output** for web dashboards or collectors
+- 🧽 Strips ANSI escape codes from logs for clean parsing
+- 🧠 Automatically resolves usernames and saves them in `~/.cl_username`
+
+---
+
+## ⚙️ Installation
+
+```bash
+pip install logmachine
+```
+
+---
+
+## 🧰 Usage
+
+### Basic Setup
+
+```python
+from logmachine import LogMachine
+
+# Create a simple logger without central logging
+# 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!")
+logger.success("Operation completed successfully!")
+logger.debug("Debugging information here.")
+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
+    "room": "team_alpha",                # Your organization or room
+    "endpoint": "/api/logs",             # Optional, defaults to /api/logs
+    "headers": {"Authorization": "Bearer token"},
+    "socketio": True,                    # Set False to use HTTP
+    "socketio_path": "/api/socket.io/"  # Optional
+}
+logger = LogMachine("with_central", debug_level=0, central=logger_config, socketio=True)
+logger.success("Central logging is working!")
+```
+
+---
+
+## 🎨 Log Format
+
+Every log includes:
+
+* ✅ Username (resolved automatically or via server)
+* 📁 Module directory
+* ⏱️ Timestamp
+* 📦 Level (INFO, ERROR, etc.)
+* 📝 Message
+
+Sample (terminal):
+
+```
+(username @ myapp) 🤌 CL Timing: [ 2025-08-04T11:23:52 ]
+[ INFO ] Server started on port 8000
+🏁
+```
+
+---
+
+## 🛠️ Advanced
+
+### Add Your Own Log Level
+
+```python
+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!")
+```
+
+---
+
+## 📤 Parse & Export
+
+### 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:
+    print(entry)
+```
+
+---
+
+## 📡 Central Server Compatibility
+
+To use Socket.IO, your central server must support these events:
+
+* `log`: Receives log payloads: `{ room: string, data: object }`
+* `GET /api/get_username?base=localname`: Returns `{ "username": "..." }`
+
+---
+
+## 🤖 Environment Variables
+
+* `CL_USERNAME`: Manually override detected username
+* Automatically stored in `~/.cl_username` for persistent identity
+
+---
+
+## 🔐 Security
+
+* HTTP headers (e.g. `Authorization`) can be injected
+* Central log transmission is fully customizable
+
+---
+
+## 🔧 Configuration Summary
+
+| Param           | Type   | Description                                        |
+| --------------- | ------ | -------------------------------------------------- |
+| `url`           | `str`  | Central server base URL                            |
+| `room`          | `str`  | Logical group or org name                          |
+| `endpoint`      | `str`  | HTTP endpoint for POST logs (default: `/api/logs`) |
+| `headers`       | `dict` | Extra headers to send (e.g. auth token)            |
+| `socketio`      | `bool` | Whether to use Socket.IO instead of HTTP           |
+| `socketio_path` | `str`  | Path to socket.io on the server                    |
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## 🙋‍♂️ Author
+
+Mugabo Gusenga
+[logmachine.bufferpunk.com](https://logmachine.bufferpunk.com)
+[GitHub](https://github.com/Scion-Kin/logmachine)
+
+---
+
+## ❤️ Contribute
+
+PRs and issues are welcome!
+This tool is built for devs who want **beautiful logs with distributed brains**.
+Let’s make debugging fun again.

logmachine-2.2.0/README.md

@@ -0,0 +1,177 @@
+# 🧠 LogMachine
+
+> Collaborative, beautiful logging system for distributed developers
+
+**logmachine** helps teams log smarter. It’s a fully pluggable logging system that supports colored output, JSON parsing, structured log forwarding via **HTTP or Socket.IO**, and log centralization — all from a standard Python logging interface.
+
+---
+
+## 🚀 Features
+
+- 🔥 **Color-coded terminal logs** (DEBUG, INFO, WARNING, ERROR, SUCCESS)
+- 📤 **Log forwarding** to a central HTTP or Socket.IO server
+- 🪵 **Custom log levels** (add your own with `.new_level(...)`)
+- 👥 **User identity tracking** for team-based logs
+- 🧩 **Pluggable backends**: send logs to a central server or local files
+- 📦 **Simple JSON output** for web dashboards or collectors
+- 🧽 Strips ANSI escape codes from logs for clean parsing
+- 🧠 Automatically resolves usernames and saves them in `~/.cl_username`
+
+---
+
+## ⚙️ Installation
+
+```bash
+pip install logmachine
+```
+
+---
+
+## 🧰 Usage
+
+### Basic Setup
+
+```python
+from logmachine import LogMachine
+
+# Create a simple logger without central logging
+# 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!")
+logger.success("Operation completed successfully!")
+logger.debug("Debugging information here.")
+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
+    "room": "team_alpha",                # Your organization or room
+    "endpoint": "/api/logs",             # Optional, defaults to /api/logs
+    "headers": {"Authorization": "Bearer token"},
+    "socketio": True,                    # Set False to use HTTP
+    "socketio_path": "/api/socket.io/"  # Optional
+}
+logger = LogMachine("with_central", debug_level=0, central=logger_config, socketio=True)
+logger.success("Central logging is working!")
+```
+
+---
+
+## 🎨 Log Format
+
+Every log includes:
+
+* ✅ Username (resolved automatically or via server)
+* 📁 Module directory
+* ⏱️ Timestamp
+* 📦 Level (INFO, ERROR, etc.)
+* 📝 Message
+
+Sample (terminal):
+
+```
+(username @ myapp) 🤌 CL Timing: [ 2025-08-04T11:23:52 ]
+[ INFO ] Server started on port 8000
+🏁
+```
+
+---
+
+## 🛠️ Advanced
+
+### Add Your Own Log Level
+
+```python
+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!")
+```
+
+---
+
+## 📤 Parse & Export
+
+### 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:
+    print(entry)
+```
+
+---
+
+## 📡 Central Server Compatibility
+
+To use Socket.IO, your central server must support these events:
+
+* `log`: Receives log payloads: `{ room: string, data: object }`
+* `GET /api/get_username?base=localname`: Returns `{ "username": "..." }`
+
+---
+
+## 🤖 Environment Variables
+
+* `CL_USERNAME`: Manually override detected username
+* Automatically stored in `~/.cl_username` for persistent identity
+
+---
+
+## 🔐 Security
+
+* HTTP headers (e.g. `Authorization`) can be injected
+* Central log transmission is fully customizable
+
+---
+
+## 🔧 Configuration Summary
+
+| Param           | Type   | Description                                        |
+| --------------- | ------ | -------------------------------------------------- |
+| `url`           | `str`  | Central server base URL                            |
+| `room`          | `str`  | Logical group or org name                          |
+| `endpoint`      | `str`  | HTTP endpoint for POST logs (default: `/api/logs`) |
+| `headers`       | `dict` | Extra headers to send (e.g. auth token)            |
+| `socketio`      | `bool` | Whether to use Socket.IO instead of HTTP           |
+| `socketio_path` | `str`  | Path to socket.io on the server                    |
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## 🙋‍♂️ Author
+
+Mugabo Gusenga
+[logmachine.bufferpunk.com](https://logmachine.bufferpunk.com)
+[GitHub](https://github.com/Scion-Kin/logmachine)
+
+---
+
+## ❤️ Contribute
+
+PRs and issues are welcome!
+This tool is built for devs who want **beautiful logs with distributed brains**.
+Let’s make debugging fun again.

logmachine-2.2.0/logmachine/__init__.py

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

{logmachine-2.0.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)
@@ -68,7 +74,7 @@ class SocketIOTransporter(logging.StreamHandler):
         self.central = kwargs.get('central', None)
         self.sio = socketio.Client()
         if self.central:
-            self.sio.connect(self.central.get('url', ''), headers=self.central.get('headers', {}), socketio_path=self.central.get('socketio_path', '/api/socket.io'))
+            self.sio.connect(self.central.get('url', ''), headers=self.central.get('headers', {}), socketio_path=self.central.get('socketio_path', '/api/socket.io/'))
 
     def emit(self, record):
         try:
@@ -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):
-                ch = RequestsTransporter(log_parser=self.parse_log, central=self.central)
+            if not kwargs.get('attached', False) and not self.central.get('socketio', False):
+                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.2.0/logmachine.egg-info/PKG-INFO

@@ -0,0 +1,195 @@
+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
+
+**logmachine** helps teams log smarter. It’s a fully pluggable logging system that supports colored output, JSON parsing, structured log forwarding via **HTTP or Socket.IO**, and log centralization — all from a standard Python logging interface.
+
+---
+
+## 🚀 Features
+
+- 🔥 **Color-coded terminal logs** (DEBUG, INFO, WARNING, ERROR, SUCCESS)
+- 📤 **Log forwarding** to a central HTTP or Socket.IO server
+- 🪵 **Custom log levels** (add your own with `.new_level(...)`)
+- 👥 **User identity tracking** for team-based logs
+- 🧩 **Pluggable backends**: send logs to a central server or local files
+- 📦 **Simple JSON output** for web dashboards or collectors
+- 🧽 Strips ANSI escape codes from logs for clean parsing
+- 🧠 Automatically resolves usernames and saves them in `~/.cl_username`
+
+---
+
+## ⚙️ Installation
+
+```bash
+pip install logmachine
+```
+
+---
+
+## 🧰 Usage
+
+### Basic Setup
+
+```python
+from logmachine import LogMachine
+
+# Create a simple logger without central logging
+# 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!")
+logger.success("Operation completed successfully!")
+logger.debug("Debugging information here.")
+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
+    "room": "team_alpha",                # Your organization or room
+    "endpoint": "/api/logs",             # Optional, defaults to /api/logs
+    "headers": {"Authorization": "Bearer token"},
+    "socketio": True,                    # Set False to use HTTP
+    "socketio_path": "/api/socket.io/"  # Optional
+}
+logger = LogMachine("with_central", debug_level=0, central=logger_config, socketio=True)
+logger.success("Central logging is working!")
+```
+
+---
+
+## 🎨 Log Format
+
+Every log includes:
+
+* ✅ Username (resolved automatically or via server)
+* 📁 Module directory
+* ⏱️ Timestamp
+* 📦 Level (INFO, ERROR, etc.)
+* 📝 Message
+
+Sample (terminal):
+
+```
+(username @ myapp) 🤌 CL Timing: [ 2025-08-04T11:23:52 ]
+[ INFO ] Server started on port 8000
+🏁
+```
+
+---
+
+## 🛠️ Advanced
+
+### Add Your Own Log Level
+
+```python
+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!")
+```
+
+---
+
+## 📤 Parse & Export
+
+### 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:
+    print(entry)
+```
+
+---
+
+## 📡 Central Server Compatibility
+
+To use Socket.IO, your central server must support these events:
+
+* `log`: Receives log payloads: `{ room: string, data: object }`
+* `GET /api/get_username?base=localname`: Returns `{ "username": "..." }`
+
+---
+
+## 🤖 Environment Variables
+
+* `CL_USERNAME`: Manually override detected username
+* Automatically stored in `~/.cl_username` for persistent identity
+
+---
+
+## 🔐 Security
+
+* HTTP headers (e.g. `Authorization`) can be injected
+* Central log transmission is fully customizable
+
+---
+
+## 🔧 Configuration Summary
+
+| Param           | Type   | Description                                        |
+| --------------- | ------ | -------------------------------------------------- |
+| `url`           | `str`  | Central server base URL                            |
+| `room`          | `str`  | Logical group or org name                          |
+| `endpoint`      | `str`  | HTTP endpoint for POST logs (default: `/api/logs`) |
+| `headers`       | `dict` | Extra headers to send (e.g. auth token)            |
+| `socketio`      | `bool` | Whether to use Socket.IO instead of HTTP           |
+| `socketio_path` | `str`  | Path to socket.io on the server                    |
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## 🙋‍♂️ Author
+
+Mugabo Gusenga
+[logmachine.bufferpunk.com](https://logmachine.bufferpunk.com)
+[GitHub](https://github.com/Scion-Kin/logmachine)
+
+---
+
+## ❤️ Contribute
+
+PRs and issues are welcome!
+This tool is built for devs who want **beautiful logs with distributed brains**.
+Let’s make debugging fun again.

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

@@ -1,6 +1,6 @@
 [project]
 name = "logmachine"
-version = "2.0.0"
+version = "2.2.0"
 description = "Collaborative, beautiful logging system for distributed developers"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -16,11 +16,11 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/Scion-Kin/logmachine"
-Documentation = "https://github.com/Scion-Kin/logmachine#readme"
-Source = "https://github.com/Scion-Kin/logmachine"
-Tracker = "https://github.com/Scion-Kin/logmachine/issues"
+Homepage = "https://logmachine.bufferpunk.com"
+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"]
+requires = ["setuptools>=61.0", "websocket-client", "python-socketio", "requests"]
 build-backend = "setuptools.build_meta"

logmachine-2.0.0/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: logmachine
-Version: 2.0.0
-Summary: Collaborative, beautiful logging system for distributed developers
-Author-email: Mugabo Gusenga <mugabo@bufferpunk.com>
-Project-URL: Homepage, https://github.com/Scion-Kin/logmachine
-Project-URL: Documentation, https://github.com/Scion-Kin/logmachine#readme
-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.0.0/logmachine/__init__.py

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

logmachine-2.0.0/logmachine.egg-info/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: logmachine
-Version: 2.0.0
-Summary: Collaborative, beautiful logging system for distributed developers
-Author-email: Mugabo Gusenga <mugabo@bufferpunk.com>
-Project-URL: Homepage, https://github.com/Scion-Kin/logmachine
-Project-URL: Documentation, https://github.com/Scion-Kin/logmachine#readme
-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