clean up log.error (#1109)

Author: ihrpr

CLAUDE.md

@@ -16,7 +16,7 @@ This document contains critical information about working with this codebase. Fo
    - Public APIs must have docstrings
    - Functions must be focused and small
    - Follow existing patterns exactly
-   - Line length: 88 chars maximum
+   - Line length: 120 chars maximum
 
 3. Testing Requirements
    - Framework: `uv run --frozen pytest`
@@ -116,3 +116,15 @@ This document contains critical information about working with this codebase. Fo
    - Follow existing patterns
    - Document public APIs
    - Test thoroughly
+
+## Exception Handling
+
+- **Always use `logger.exception()` instead of `logger.error()` when catching exceptions**
+  - Don't include the exception in the message: `logger.exception("Failed")` not `logger.exception(f"Failed: {e}")`
+- **Catch specific exceptions** where possible:
+  - File ops: `except (OSError, PermissionError):`
+  - JSON: `except json.JSONDecodeError:`
+  - Network: `except (ConnectionError, TimeoutError):`
+- **Only catch `Exception` for**:
+  - Top-level handlers that must not crash
+  - Cleanup blocks (log at debug level)

examples/servers/simple-auth/mcp_simple_auth/server.py

@@ -160,9 +160,8 @@ def main(port: int, auth_server: str, transport: Literal["sse", "streamable-http
         mcp_server.run(transport=transport)
         logger.info("Server stopped")
         return 0
-    except Exception as e:
-        logger.error(f"Server error: {e}")
-        logger.exception("Exception details:")
+    except Exception:
+        logger.exception("Server error")
         return 1
 
 

src/mcp/cli/claude.py

@@ -75,11 +75,10 @@ def update_claude_config(
     if not config_file.exists():
         try:
             config_file.write_text("{}")
-        except Exception as e:
-            logger.error(
+        except Exception:
+            logger.exception(
                 "Failed to create Claude config file",
                 extra={
-                    "error": str(e),
                     "config_file": str(config_file),
                 },
             )
@@ -139,11 +138,10 @@ def update_claude_config(
             extra={"config_file": str(config_file)},
         )
         return True
-    except Exception as e:
-        logger.error(
+    except Exception:
+        logger.exception(
             "Failed to update Claude config",
             extra={
-                "error": str(e),
                 "config_file": str(config_file),
             },
         )

src/mcp/cli/cli.py

@@ -349,12 +349,11 @@ def run(
 
         server.run(**kwargs)
 
-    except Exception as e:
-        logger.error(
-            f"Failed to run server: {e}",
+    except Exception:
+        logger.exception(
+            "Failed to run server",
             extra={
                 "file": str(file),
-                "error": str(e),
             },
         )
         sys.exit(1)
@@ -464,8 +463,8 @@ def install(
             if dotenv:
                 try:
                     env_dict |= {k: v for k, v in dotenv.dotenv_values(env_file).items() if v is not None}
-                except Exception as e:
-                    logger.error(f"Failed to load .env file: {e}")
+                except (OSError, ValueError):
+                    logger.exception("Failed to load .env file")
                     sys.exit(1)
             else:
                 logger.error("python-dotenv is not installed. Cannot load .env file.")

src/mcp/client/auth.py

@@ -464,8 +464,8 @@ async def _handle_refresh_response(self, response: httpx.Response) -> bool:
             await self.context.storage.set_tokens(token_response)
 
             return True
-        except ValidationError as e:
-            logger.error(f"Invalid refresh response: {e}")
+        except ValidationError:
+            logger.exception("Invalid refresh response")
             self.context.clear_tokens()
             return False
 
@@ -522,8 +522,8 @@ async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.
                     token_request = await self._exchange_token(auth_code, code_verifier)
                     token_response = yield token_request
                     await self._handle_token_response(token_response)
-                except Exception as e:
-                    logger.error(f"OAuth flow error: {e}")
+                except Exception:
+                    logger.exception("OAuth flow error")
                     raise
 
             # Add authorization header and make request

src/mcp/client/sse.py

@@ -97,7 +97,7 @@ async def sse_reader(
                                             )
                                             logger.debug(f"Received server message: {message}")
                                         except Exception as exc:
-                                            logger.error(f"Error parsing server message: {exc}")
+                                            logger.exception("Error parsing server message")
                                             await read_stream_writer.send(exc)
                                             continue
 
@@ -106,7 +106,7 @@ async def sse_reader(
                                     case _:
                                         logger.warning(f"Unknown SSE event: {sse.event}")
                         except Exception as exc:
-                            logger.error(f"Error in sse_reader: {exc}")
+                            logger.exception("Error in sse_reader")
                             await read_stream_writer.send(exc)
                         finally:
                             await read_stream_writer.aclose()
@@ -126,8 +126,8 @@ async def post_writer(endpoint_url: str):
                                     )
                                     response.raise_for_status()
                                     logger.debug(f"Client message sent successfully: {response.status_code}")
-                        except Exception as exc:
-                            logger.error(f"Error in post_writer: {exc}")
+                        except Exception:
+                            logger.exception("Error in post_writer")
                         finally:
                             await write_stream.aclose()
 

src/mcp/client/streamable_http.py

@@ -308,7 +308,7 @@ async def _handle_json_response(
             session_message = SessionMessage(message)
             await read_stream_writer.send(session_message)
         except Exception as exc:
-            logger.error(f"Error parsing JSON response: {exc}")
+            logger.exception("Error parsing JSON response")
             await read_stream_writer.send(exc)
 
     async def _handle_sse_response(
@@ -410,8 +410,8 @@ async def handle_request_async():
                     else:
                         await handle_request_async()
 
-        except Exception as exc:
-            logger.error(f"Error in post_writer: {exc}")
+        except Exception:
+            logger.exception("Error in post_writer")
         finally:
             await read_stream_writer.aclose()
             await write_stream.aclose()

src/mcp/os/posix/utilities.py

@@ -52,9 +52,9 @@ async def terminate_posix_process_tree(process: Process, timeout_seconds: float
             process.terminate()
             with anyio.fail_after(timeout_seconds):
                 await process.wait()
-        except Exception as term_error:
-            logger.warning(f"Process termination failed for PID {pid}: {term_error}, attempting force kill")
+        except Exception:
+            logger.warning(f"Process termination failed for PID {pid}, attempting force kill")
             try:
                 process.kill()
-            except Exception as kill_error:
-                logger.error(f"Failed to kill process {pid}: {kill_error}")
+            except Exception:
+                logger.exception(f"Failed to kill process {pid}")

src/mcp/server/fastmcp/server.py

@@ -311,7 +311,7 @@ async def read_resource(self, uri: AnyUrl | str) -> Iterable[ReadResourceContent
             content = await resource.read()
             return [ReadResourceContents(content=content, mime_type=resource.mime_type)]
         except Exception as e:
-            logger.error(f"Error reading resource {uri}: {e}")
+            logger.exception(f"Error reading resource {uri}")
             raise ResourceError(str(e))
 
     def add_tool(
@@ -961,7 +961,7 @@ async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -
 
             return GetPromptResult(messages=pydantic_core.to_jsonable_python(messages))
         except Exception as e:
-            logger.error(f"Error getting prompt {name}: {e}")
+            logger.exception(f"Error getting prompt {name}")
             raise ValueError(str(e))
 
 

src/mcp/server/sse.py

@@ -105,8 +105,8 @@ def __init__(self, endpoint: str, security_settings: TransportSecuritySettings |
         # Validate that endpoint is a relative path and not a full URL
         if "://" in endpoint or endpoint.startswith("//") or "?" in endpoint or "#" in endpoint:
             raise ValueError(
-                f"Given endpoint: {endpoint} is not a relative path (e.g., '/messages/'), \
-                             expecting a relative path(e.g., '/messages/')."
+                f"Given endpoint: {endpoint} is not a relative path (e.g., '/messages/'), "
+                "expecting a relative path (e.g., '/messages/')."
             )
 
         # Ensure endpoint starts with a forward slash
@@ -234,7 +234,7 @@ async def handle_post_message(self, scope: Scope, receive: Receive, send: Send)
             message = types.JSONRPCMessage.model_validate_json(body)
             logger.debug(f"Validated client message: {message}")
         except ValidationError as err:
-            logger.error(f"Failed to parse message: {err}")
+            logger.exception("Failed to parse message")
             response = Response("Could not parse message", status_code=400)
             await response(scope, receive, send)
             await writer.send(err)