refactor: :loud_sound: replace all print with logger.debug

5 files changed, 40 insertions, 62 deletions

diff --git a/continuedev/src/continuedev/server/gui.py b/continuedev/src/continuedev/server/gui.py
index 58e875b9..2adb680e 100644
--- a/continuedev/src/continuedev/server/gui.py
+++ b/continuedev/src/continuedev/server/gui.py
@@ -12,6 +12,7 @@ from .gui_protocol import AbstractGUIProtocolServer
 from ..libs.util.queue import AsyncSubscriptionQueue
 from ..libs.util.telemetry import posthog_logger
 from ..libs.util.create_async_task import create_async_task
+from ..libs.util.logging import logger
 
 router = APIRouter(prefix="/gui", tags=["gui"])
 
@@ -25,7 +26,7 @@ class AppStatus:
     @staticmethod
     def handle_exit(*args, **kwargs):
         AppStatus.should_exit = True
-        print("Shutting down")
+        logger.debug("Shutting down")
         original_handler(*args, **kwargs)
 
 
@@ -96,7 +97,7 @@ class GUIProtocolServer(AbstractGUIProtocolServer):
             elif message_type == "select_context_item":
                 self.select_context_item(data["id"], data["query"])
         except Exception as e:
-            print(e)
+            logger.debug(e)
 
     def on_main_input(self, input: str):
         # Do something with user input
@@ -162,10 +163,10 @@ class GUIProtocolServer(AbstractGUIProtocolServer):
 @router.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket, session: Session = Depends(websocket_session)):
     try:
-        print("Received websocket connection at url: ", websocket.url)
+        logger.debug(f"Received websocket connection at url: {websocket.url}")
         await websocket.accept()
 
-        print("Session started")
+        logger.debug("Session started")
         session_manager.register_websocket(session.session_id, websocket)
         protocol = GUIProtocolServer(session)
         protocol.websocket = websocket
@@ -175,7 +176,7 @@ async def websocket_endpoint(websocket: WebSocket, session: Session = Depends(we
 
         while AppStatus.should_exit is False:
             message = await websocket.receive_text()
-            print("Received GUI message", message)
+            logger.debug(f"Received GUI message {message}")
             if type(message) is str:
                 message = json.loads(message)
 
@@ -186,14 +187,14 @@ async def websocket_endpoint(websocket: WebSocket, session: Session = Depends(we
 
             protocol.handle_json(message_type, data)
     except WebSocketDisconnect as e:
-        print("GUI websocket disconnected")
+        logger.debug("GUI websocket disconnected")
     except Exception as e:
-        print("ERROR in gui websocket: ", e)
+        logger.debug(f"ERROR in gui websocket: {e}")
         posthog_logger.capture_event("gui_error", {
             "error_title": e.__str__() or e.__repr__(), "error_message": '\n'.join(traceback.format_exception(e))})
         raise e
     finally:
-        print("Closing gui websocket")
+        logger.debug("Closing gui websocket")
         if websocket.client_state != WebSocketState.DISCONNECTED:
             await websocket.close()
 
diff --git a/continuedev/src/continuedev/server/ide.py b/continuedev/src/continuedev/server/ide.py
index e4c2d714..8a269cb7 100644
--- a/continuedev/src/continuedev/server/ide.py
+++ b/continuedev/src/continuedev/server/ide.py
@@ -19,6 +19,7 @@ from .gui import session_manager
 from .ide_protocol import AbstractIdeProtocolServer
 from ..libs.util.create_async_task import create_async_task
 from .session_manager import SessionManager
+from ..libs.util.logging import logger
 
 import nest_asyncio
 nest_asyncio.apply()
@@ -37,7 +38,7 @@ class AppStatus:
     @staticmethod
     def handle_exit(*args, **kwargs):
         AppStatus.should_exit = True
-        print("Shutting down")
+        logger.debug("Shutting down")
         original_handler(*args, **kwargs)
 
 
@@ -140,7 +141,7 @@ class IdeProtocolServer(AbstractIdeProtocolServer):
                 continue
             message_type = message["messageType"]
             data = message["data"]
-            print("Received message while initializing", message_type)
+            logger.debug(f"Received message while initializing {message_type}")
             if message_type == "workspaceDirectory":
                 self.workspace_directory = data["workspaceDirectory"]
             elif message_type == "uniqueId":
@@ -154,9 +155,10 @@ class IdeProtocolServer(AbstractIdeProtocolServer):
 
     async def _send_json(self, message_type: str, data: Any):
         if self.websocket.application_state == WebSocketState.DISCONNECTED:
-            print("Tried to send message, but websocket is disconnected", message_type)
+            logger.debug(
+                f"Tried to send message, but websocket is disconnected: {message_type}")
             return
-        print("Sending IDE message: ", message_type)
+        logger.debug(f"Sending IDE message: {message_type}")
         await self.websocket.send_json({
             "messageType": message_type,
             "data": data
@@ -167,7 +169,7 @@ class IdeProtocolServer(AbstractIdeProtocolServer):
             return await asyncio.wait_for(self.sub_queue.get(message_type), timeout=timeout)
         except asyncio.TimeoutError:
             raise Exception(
-                "IDE Protocol _receive_json timed out after 20 seconds", message_type)
+                f"IDE Protocol _receive_json timed out after 20 seconds: {message_type}")
 
     async def _send_and_receive_json(self, data: Any, resp_model: Type[T], message_type: str) -> T:
         await self._send_json(message_type, data)
@@ -354,7 +356,7 @@ class IdeProtocolServer(AbstractIdeProtocolServer):
             }, GetUserSecretResponse, "getUserSecret")
             return resp.value
         except Exception as e:
-            print("Error getting user secret", e)
+            logger.debug(f"Error getting user secret: {e}")
             return ""
 
     async def saveFile(self, filepath: str):
@@ -437,15 +439,15 @@ class IdeProtocolServer(AbstractIdeProtocolServer):
 async def websocket_endpoint(websocket: WebSocket, session_id: str = None):
     try:
         await websocket.accept()
-        print("Accepted websocket connection from, ", websocket.client)
+        logger.debug(f"Accepted websocket connection from {websocket.client}")
         await websocket.send_json({"messageType": "connected", "data": {}})
 
         # Start meilisearch
         try:
             await start_meilisearch()
         except Exception as e:
-            print("Failed to start MeiliSearch")
-            print(e)
+            logger.debug("Failed to start MeiliSearch")
+            logger.debug(e)
 
         def handle_msg(msg):
             message = json.loads(msg)
@@ -455,7 +457,7 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str = None):
             message_type = message["messageType"]
             data = message["data"]
 
-            print("Received IDE message: ", message_type)
+            logger.debug(f"Received IDE message: {message_type}")
             create_async_task(
                 ideProtocolServer.handle_json(message_type, data))
 
@@ -473,16 +475,16 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str = None):
             message = await websocket.receive_text()
             handle_msg(message)
 
-        print("Closing ide websocket")
+        logger.debug("Closing ide websocket")
     except WebSocketDisconnect as e:
-        print("IDE wbsocket disconnected")
+        logger.debug("IDE wbsocket disconnected")
     except Exception as e:
-        print("Error in ide websocket: ", e)
+        logger.debug(f"Error in ide websocket: {e}")
         posthog_logger.capture_event("gui_error", {
             "error_title": e.__str__() or e.__repr__(), "error_message": '\n'.join(traceback.format_exception(e))})
         raise e
     finally:
-        print("Closing ide websocket")
+        logger.debug("Closing ide websocket")
         if websocket.client_state != WebSocketState.DISCONNECTED:
             await websocket.close()
 
diff --git a/continuedev/src/continuedev/server/main.py b/continuedev/src/continuedev/server/main.py
index 1c7a135c..13f6b840 100644
--- a/continuedev/src/continuedev/server/main.py
+++ b/continuedev/src/continuedev/server/main.py
@@ -15,6 +15,7 @@ from .ide import router as ide_router
 from .gui import router as gui_router
 from .session_manager import session_manager
 from ..libs.util.paths import getLogFilePath
+from ..libs.util.logging import logger
 
 app = FastAPI()
 
@@ -33,7 +34,7 @@ app.add_middleware(
 
 @app.get("/health")
 def health():
-    print("Health check")
+    logger.debug("Health check")
     return {"status": "ok"}
 
 
@@ -56,31 +57,6 @@ class Logger(object):
         return False
 
 
-def setup_logging():
-    log_path = getLogFilePath()
-    LOG_CONFIG = {
-        'version': 1,
-        'disable_existing_loggers': False,
-        'handlers': {
-            'file': {
-                'level': 'DEBUG',
-                'class': 'logging.FileHandler',
-                'filename': log_path,
-            },
-        },
-        'root': {
-            'level': 'DEBUG',
-            'handlers': ['file']
-        }
-    }
-
-    logger = Logger(log_path)
-    print(f"Log path: {log_path}")
-    # sys.stdout = logger
-    # sys.stderr = logger
-    print("Testing logs")
-
-
 try:
     # add cli arg for server port
     parser = argparse.ArgumentParser()
@@ -88,21 +64,19 @@ try:
                         type=int, default=65432)
     args = parser.parse_args()
 except Exception as e:
-    print("Error parsing command line arguments: ", e)
+    logger.debug(f"Error parsing command line arguments: {e}")
     raise e
 
 
 def run_server():
-    config = uvicorn.Config(app, host="0.0.0.0", port=args.port,
-                            # log_config=LOG_CONFIG
-                            )
+    config = uvicorn.Config(app, host="0.0.0.0", port=args.port)
     server = uvicorn.Server(config)
 
     server.run()
 
 
 async def cleanup_coroutine():
-    print("Cleaning up sessions")
+    logger.debug("Cleaning up sessions")
     for session_id in session_manager.sessions:
         await session_manager.persist_session(session_id)
 
@@ -121,7 +95,7 @@ def cpu_usage_report():
     time.sleep(1)
     # Call cpu_percent again to get the CPU usage over the interval
     cpu_usage = process.cpu_percent(interval=None)
-    print(f"CPU usage: {cpu_usage}%")
+    logger.debug(f"CPU usage: {cpu_usage}%")
 
 
 atexit.register(cleanup)
@@ -139,9 +113,8 @@ if __name__ == "__main__":
         # cpu_thread = threading.Thread(target=cpu_usage_loop)
         # cpu_thread.start()
 
-        setup_logging()
         run_server()
     except Exception as e:
-        print("Error starting Continue server: ", e)
+        logger.debug(f"Error starting Continue server: {e}")
         cleanup()
         raise e
diff --git a/continuedev/src/continuedev/server/meilisearch_server.py b/continuedev/src/continuedev/server/meilisearch_server.py
index 00f692f5..7f460afc 100644
--- a/continuedev/src/continuedev/server/meilisearch_server.py
+++ b/continuedev/src/continuedev/server/meilisearch_server.py
@@ -5,6 +5,7 @@ import subprocess
 from meilisearch_python_async import Client
 
 from ..libs.util.paths import getServerFolderPath
+from ..libs.util.logging import logger
 
 
 def ensure_meilisearch_installed() -> bool:
@@ -39,7 +40,7 @@ def ensure_meilisearch_installed() -> bool:
             shutil.rmtree(p, ignore_errors=True)
 
         # Download MeiliSearch
-        print("Downloading MeiliSearch...")
+        logger.debug("Downloading MeiliSearch...")
         subprocess.run(
             f"curl -L https://install.meilisearch.com | sh", shell=True, check=True, cwd=serverPath)
 
@@ -82,6 +83,6 @@ async def start_meilisearch():
 
     # Check if MeiliSearch is running
     if not await check_meilisearch_running() or not was_already_installed:
-        print("Starting MeiliSearch...")
+        logger.debug("Starting MeiliSearch...")
         subprocess.Popen(["./meilisearch", "--no-analytics"], cwd=serverPath, stdout=subprocess.DEVNULL,
                          stderr=subprocess.STDOUT, close_fds=True, start_new_session=True)
diff --git a/continuedev/src/continuedev/server/session_manager.py b/continuedev/src/continuedev/server/session_manager.py
index 511dc070..d30411cd 100644
--- a/continuedev/src/continuedev/server/session_manager.py
+++ b/continuedev/src/continuedev/server/session_manager.py
@@ -15,6 +15,7 @@ from ..core.autopilot import Autopilot
 from .ide_protocol import AbstractIdeProtocolServer
 from ..libs.util.create_async_task import create_async_task
 from ..libs.util.errors import SessionNotFound
+from ..libs.util.logging import logger
 
 
 class Session:
@@ -61,7 +62,7 @@ class SessionManager:
         return self.sessions[session_id]
 
     async def new_session(self, ide: AbstractIdeProtocolServer, session_id: Union[str, None] = None) -> Session:
-        print("New session: ", session_id)
+        logger.debug(f"New session: {session_id}")
 
         full_state = None
         if session_id is not None and os.path.exists(getSessionFilePath(session_id)):
@@ -86,7 +87,7 @@ class SessionManager:
         return session
 
     async def remove_session(self, session_id: str):
-        print("Removing session: ", session_id)
+        logger.debug(f"Removing session: {session_id}")
         if session_id in self.sessions:
             if session_id in self.registered_ides:
                 ws_to_close = self.registered_ides[session_id].websocket
@@ -103,13 +104,13 @@ class SessionManager:
 
     def register_websocket(self, session_id: str, ws: WebSocket):
         self.sessions[session_id].ws = ws
-        print("Registered websocket for session", session_id)
+        logger.debug(f"Registered websocket for session {session_id}")
 
     async def send_ws_data(self, session_id: str, message_type: str, data: Any):
         if session_id not in self.sessions:
             raise SessionNotFound(f"Session {session_id} not found")
         if self.sessions[session_id].ws is None:
-            # print(f"Session {session_id} has no websocket")
+            # logger.debug(f"Session {session_id} has no websocket")
             return
 
         await self.sessions[session_id].ws.send_json({