Use named loggers in Python (#1157)

Author: FeodorFitsner

sdk/python/packages/flet-core/src/flet_core/local_connection.py

@@ -1,9 +1,12 @@
 import logging
 from typing import List
 
+import flet_core
 from flet_core.connection import Connection
 from flet_core.protocol import *
 
+logger = logging.getLogger(flet_core.__name__)
+
 
 class LocalConnection(Connection):
     def __init__(self):
@@ -71,7 +74,7 @@ def _create_update_control_props_handler_arg(self, msg: ClientMessage):
         )
 
     def _process_command(self, command: Command):
-        logging.debug("_process_command: {}".format(command))
+        logger.debug("_process_command: {}".format(command))
         if command.name == "get":
             return self._process_get_command(command.values)
         elif command.name == "add":

sdk/python/packages/flet-core/src/flet_core/page.py

@@ -8,6 +8,7 @@
 from typing import Any, Dict, List, Optional, Tuple, Union, cast
 from urllib.parse import urlparse
 
+import flet_core
 from flet_core.app_bar import AppBar
 from flet_core.banner import Banner
 from flet_core.client_storage import ClientStorage
@@ -37,6 +38,9 @@
 from flet_core.utils import is_asyncio, is_coroutine
 from flet_core.view import View
 
+logger = logging.getLogger(flet_core.__name__)
+
+
 try:
     from flet.auth.authorization import Authorization
     from flet.auth.oauth_provider import OAuthProvider
@@ -429,7 +433,7 @@ async def error_async(self, message=""):
             await self._send_command_async("error", [message])
 
     def on_event(self, e: Event):
-        logging.info(f"page.on_event: {e.target} {e.name} {e.data}")
+        logger.info(f"page.on_event: {e.target} {e.name} {e.data}")
         with self.__lock:
             if e.target == "page" and e.name == "change":
                 self.__on_page_change_event(e.data)
@@ -442,7 +446,7 @@ def on_event(self, e: Event):
                     t.start()
 
     async def on_event_async(self, e: Event):
-        logging.info(f"page.on_event_async: {e.target} {e.name} {e.data}")
+        logger.info(f"page.on_event_async: {e.target} {e.name} {e.data}")
 
         if e.target == "page" and e.name == "change":
             async with self.__async_lock:

sdk/python/packages/flet-pyodide/src/flet/flet.py

@@ -1,6 +1,7 @@
 import logging
 import traceback
 
+import flet
 import flet_js
 from flet.pyodide_connection import PyodideConnection
 from flet_core.event import Event
@@ -17,6 +18,9 @@
 FLET_APP_HIDDEN = "flet_app_hidden"
 
 
+logger = logging.getLogger(flet.__name__)
+
+
 def app(
     target,
     name="",
@@ -61,14 +65,14 @@ async def on_event(e):
                 Event(e.eventTarget, e.eventName, e.eventData)
             )
             if e.eventTarget == "page" and e.eventName == "close":
-                logging.info(f"Session closed: {e.sessionID}")
+                logger.info(f"Session closed: {e.sessionID}")
                 del conn.sessions[e.sessionID]
 
     async def on_session_created(session_data):
         page = Page(conn, session_data.sessionID)
         await page.fetch_page_details_async()
         conn.sessions[session_data.sessionID] = page
-        logging.info(f"Session started: {session_data.sessionID}")
+        logger.info(f"Session started: {session_data.sessionID}")
         try:
             assert target is not None
             if is_coroutine(target):

sdk/python/packages/flet-pyodide/src/flet/pyodide_connection.py

@@ -3,6 +3,7 @@
 import logging
 from typing import List
 
+import flet
 import flet_js
 import js
 from flet_core.local_connection import LocalConnection
@@ -16,6 +17,8 @@
     RegisterWebClientRequestPayload,
 )
 
+logger = logging.getLogger(flet.__name__)
+
 
 class PyodideConnection(LocalConnection):
     def __init__(
@@ -30,7 +33,7 @@ def __init__(
         flet_js.start_connection = self.connect
 
     async def connect(self, send_callback):
-        logging.info("Starting Pyodide connection...")
+        logger.info("Starting Pyodide connection...")
         self.page_url = flet_js.documentUrl
         self.send_callback = send_callback
         asyncio.create_task(self.receive_loop())
@@ -42,11 +45,11 @@ async def receive_loop(self):
             await self.__on_message(message)
 
     def send_from_js(self, message: str):
-        logging.debug(f"Sending data from JavaScript to Python: {message}")
+        logger.debug(f"Sending data from JavaScript to Python: {message}")
         self.__receive_queue.put_nowait(message)
 
     async def __on_message(self, data: str):
-        logging.debug(f"_on_message: {data}")
+        logger.debug(f"_on_message: {data}")
         msg_dict = json.loads(data)
         msg = ClientMessage(**msg_dict)
         if msg.action == ClientActions.REGISTER_WEB_CLIENT:
@@ -103,5 +106,5 @@ def send_commands(self, session_id: str, commands: List[Command]):
 
     def __send(self, message: ClientMessage):
         j = json.dumps(message, cls=CommandEncoder, separators=(",", ":"))
-        logging.debug(f"__send: {j}")
+        logger.debug(f"__send: {j}")
         self.send_callback(j)

sdk/python/packages/flet/src/flet/__pyinstaller/rthooks/pyi_rth_localhost_fletd.py

@@ -1,6 +1,11 @@
 import logging
 import os
 
-logging.info("Running PyInstaller runtime hook for Flet...")
+import flet
+
+logger = logging.getLogger(flet.__name__)
+
+
+logger.info("Running PyInstaller runtime hook for Flet...")
 
 os.environ["FLET_SERVER_IP"] = "127.0.0.1"

sdk/python/packages/flet/src/flet/async_local_socket_connection.py

@@ -2,13 +2,12 @@
 import json
 import logging
 import os
-import socket
 import struct
 import tempfile
-import threading
 from pathlib import Path
 from typing import List, Optional
 
+import flet
 from flet.utils import get_free_tcp_port, is_windows
 from flet_core.local_connection import LocalConnection
 from flet_core.protocol import (
@@ -22,6 +21,8 @@
 )
 from flet_core.utils import random_string
 
+logger = logging.getLogger(flet.__name__)
+
 
 class AsyncLocalSocketConnection(LocalConnection):
     def __init__(
@@ -45,7 +46,7 @@ async def connect(self):
             host = "localhost"
             port = self.__port if self.__port > 0 else get_free_tcp_port()
             self.page_url = f"tcp://{host}:{port}"
-            logging.info(f"Starting up TCP server on {host}:{port}")
+            logger.info(f"Starting up TCP server on {host}:{port}")
             server = await asyncio.start_server(self.handle_connection, host, port)
             self.__server = asyncio.create_task(server.serve_forever())
         else:
@@ -55,7 +56,7 @@ async def connect(self):
                     Path(tempfile.gettempdir()).joinpath(random_string(10))
                 )
             self.page_url = self.__uds_path
-            logging.info(f"Starting up UDS server on {self.__uds_path}")
+            logger.info(f"Starting up UDS server on {self.__uds_path}")
             server = await asyncio.start_unix_server(
                 self.handle_connection, self.__uds_path
             )
@@ -66,7 +67,7 @@ async def handle_connection(
     ):
         if not self.__connected:
             self.__connected = True
-            logging.debug("Connected new TCP client")
+            logger.debug("Connected new TCP client")
             self.__receive_loop_task = asyncio.create_task(self.__receive_loop(reader))
             self.__send_loop_task = asyncio.create_task(self.__send_loop(writer))
 
@@ -92,14 +93,14 @@ async def __send_loop(self, writer: asyncio.StreamWriter):
                 msg = struct.pack(">I", len(data)) + data
                 writer.write(msg)
                 # await writer.drain()
-                logging.debug("sent to TCP: {}".format(len(msg)))
+                logger.debug("sent to TCP: {}".format(len(msg)))
             except:
                 # re-enqueue the message to repeat it when re-connected
                 self.__send_queue.put_nowait(message)
                 raise
 
     async def __on_message(self, data: str):
-        logging.debug(f"_on_message: {data}")
+        logger.debug(f"_on_message: {data}")
         msg_dict = json.loads(data)
         msg = ClientMessage(**msg_dict)
         if msg.action == ClientActions.REGISTER_WEB_CLIENT:
@@ -152,11 +153,11 @@ async def send_commands_async(self, session_id: str, commands: List[Command]):
 
     async def __send(self, message: ClientMessage):
         j = json.dumps(message, cls=CommandEncoder, separators=(",", ":"))
-        logging.debug(f"__send: {j}")
+        logger.debug(f"__send: {j}")
         await self.__send_queue.put(j)
 
     async def close(self):
-        logging.debug("Closing connection...")
+        logger.debug("Closing connection...")
         # close socket
         if self.__receive_loop_task:
             self.__receive_loop_task.cancel()

sdk/python/packages/flet/src/flet/async_websocket_connection.py

@@ -5,6 +5,7 @@
 from asyncio.queues import Queue
 from typing import List, Optional
 
+import flet
 import websockets.client as ws_client
 from flet import constants
 from flet_core.connection import Connection
@@ -24,6 +25,8 @@
 )
 from websockets.client import WebSocketClientProtocol
 
+logger = logging.getLogger(flet.__name__)
+
 
 class AsyncWebSocketConnection(Connection):
     __CONNECT_TIMEOUT = 0.2
@@ -50,22 +53,22 @@ def __init__(
 
     async def connect(self):
         ws_url = self._get_ws_url(self.__server_address)
-        logging.debug(f"Connecting via WebSockets to {ws_url}...")
+        logger.debug(f"Connecting via WebSockets to {ws_url}...")
 
         attempt = self.__CONNECT_ATTEMPTS
         while True:
             try:
                 self.__ws: WebSocketClientProtocol = await ws_client.connect(ws_url)
                 break
             except Exception as e:
-                logging.debug(f"Error connecting to Flet server: {e}")
+                logger.debug(f"Error connecting to Flet server: {e}")
                 if attempt == 0 and not self.__is_reconnecting:
                     raise Exception(
                         f"Failed to connect Flet server in {self.__CONNECT_ATTEMPTS} attempts."
                     )
                 attempt -= 1
                 await asyncio.sleep(self.__CONNECT_TIMEOUT)
-        logging.debug(f"Connected to Flet server {self.__server_address}")
+        logger.debug(f"Connected to Flet server {self.__server_address}")
         self.__is_reconnecting = True
 
         # start send/receive loops
@@ -104,19 +107,19 @@ async def __start_loops(self):
             name = task.get_name()
             exception = task.exception()
             if isinstance(exception, Exception):
-                logging.error(f"{name} threw {exception}")
+                logger.error(f"{name} threw {exception}")
                 failed = True
         for task in pending:
             task.cancel()
 
         # re-connect if one of tasks failed
         if failed:
-            logging.debug(f"Re-connecting to Flet server in 1 second")
+            logger.debug(f"Re-connecting to Flet server in 1 second")
             await asyncio.sleep(self.__CONNECT_TIMEOUT)
             await self.connect()
 
     async def __on_ws_message(self, data):
-        logging.debug(f"_on_message: {data}")
+        logger.debug(f"_on_message: {data}")
         msg_dict = json.loads(data)
         msg = Message(**msg_dict)
         if msg.id:
@@ -176,15 +179,15 @@ async def _send_message_with_result(self, action_name, payload):
         msg_id = uuid.uuid4().hex
         msg = Message(msg_id, action_name, payload)
         j = json.dumps(msg, cls=CommandEncoder, separators=(",", ":"))
-        logging.debug(f"_send_message_with_result: {j}")
+        logger.debug(f"_send_message_with_result: {j}")
         evt = asyncio.Event()
         self.__ws_callbacks[msg_id] = (evt, None)
         await self.__send_queue.put(j)
         await evt.wait()
         return self.__ws_callbacks.pop(msg_id)[1]
 
     async def close(self):
-        logging.debug("Closing WebSockets connection...")
+        logger.debug("Closing WebSockets connection...")
         if self.__receive_loop_task:
             self.__receive_loop_task.cancel()
         if self.__send_loop_task: