end-of-file

docs/docs/Components/components-custom-components.mdx

@@ -546,67 +546,56 @@ You can modify additional field properties in `update_build_config` other than j
 
 ## Error handling and logging
 
-In Langflow, robust error handling ensures that your components behave predictably, even when unexpected situations occur, such as invalid inputs, external API failures, or internal logic errors.
+You can raise standard Python exceptions such as `ValueError` or specialized exceptions like `ToolException` when validation fails. Langflow automatically catches these and displays appropriate error messages in the visual editor, helping users quickly identify what went wrong.
 
-### Error handling techniques
+```python
+def compute_result(self) -> str:
+    if not self.user_input:
+        raise ValueError("No input provided.")
+    # ...
+```
 
-* **Raise Exceptions**: If a critical error occurs, you can raise standard Python exceptions such as `ValueError`, or specialized exceptions like `ToolException`. Langflow will automatically catch these and display appropriate error messages in the visual editor, helping users quickly identify what went wrong.
+Alternatively, instead of stopping a flow abruptly, you can return a `Data` object containing an `"error"` field. This approach allows the flow to continue operating and enables downstream components to detect and handle the error gracefully.
 
-    ```python
-    def compute_result(self) -> str:
-        if not self.user_input:
-            raise ValueError("No input provided.")
+```python
+def run_model(self) -> Data:
+    try:
         # ...
-    ```
-
-* **Return Structured Error Data**: Instead of stopping a flow abruptly, you can return a Data object containing an "error" field. This approach allows the flow to continue operating and enables downstream components to detect and handle the error gracefully.
-
-    ```python
-    def run_model(self) -> Data:
-        try:
-            # ...
-        except Exception as e:
-            return Data(data={"error": str(e)})
-    ```
-
-### Improve debugging and flow management
+    except Exception as e:
+        return Data(data={"error": str(e)})
+```
 
-* **Use `self.status`**: Each component has a status field where you can store short messages about the execution result—such as success summaries, partial progress, or error notifications. These appear directly in the visual editor, making troubleshooting easier for users.
+Langflow provides several tools to help you debug and manage component execution. You can use `self.status` to display short messages about execution results directly in the visual editor, making troubleshooting easier for users.
 
-    ```python
-    def parse_data(self) -> Data:
-    # ...
-    self.status = f"Parsed {len(rows)} rows successfully."
-    return Data(data={"rows": rows})
-    ```
+```python
+def parse_data(self) -> Data:
+# ...
+self.status = f"Parsed {len(rows)} rows successfully."
+return Data(data={"rows": rows})
+```
 
-* **Stop specific outputs with `self.stop(...)`**: You can halt individual output paths when certain conditions fail, without affecting the entire component. This is especially useful when working with components that have multiple output branches.
+You can halt individual output paths when certain conditions fail using `self.stop()`, without stopping other outputs from the same component.
 
-    ```python
-    def some_output(self) -> Data:
-    if <some condition>:
-        self.stop("some_output")  # Tells Langflow no data flows
-        return Data(data={"error": "Condition not met"})
-    ```
+This example stops the output if the user input is empty, preventing the component from processing invalid data.
 
-* **Log events**: You can log key execution details inside components. Logs are displayed in the "Logs" or "Events" section of the component's detail view and can be accessed later through the flow's debug panel or exported files, providing a clear trace of the component's behavior for easier debugging.
+```python
+def some_output(self) -> Data:
+if not self.user_input or len(self.user_input.strip()) == 0:
+    self.stop("some_output")
+    return Data(data={"error": "Empty input provided"})
+```
 
-    ```python
-    def process_file(self, file_path: str):
-    self.log(f"Processing file {file_path}")
-    # ...
-    ```
+You can log key execution details inside components using `self.log()`. These logs are stored as structured data and displayed in the "Logs" or "Events" section of the component's detail view, and can be accessed later through the **Logs** button in the visual editor or exported files.
 
-### Tips for error handling and logging
+Component logs are distinct from Langflow's main application logging system. `self.log()` creates component-specific logs that appear in the UI, while Langflow's main logging system uses [structlog](https://www.structlog.org) for application-level logging  that outputs to `langflow.log` files. For more information, see [Logs](/logging).
 
-To build more reliable components, consider the following best practices:
+This example logs a message when the component starts processing a file.
 
-* **Validate inputs early**: Catch missing or invalid inputs at the start to prevent broken logic.
-* **Summarize with `self.status`**: Use short success or error summaries to help users understand results quickly.
-* **Keep logs concise**: Focus on meaningful messages to avoid cluttering the visual editor.
-* **Return structured errors**: When appropriate, return `Data(data={"error": ...})` instead of raising exceptions to allow downstream handling.
-* **Stop outputs selectively**: Only halt specific outputs with `self.stop(...)` if necessary, to preserve correct flow behavior elsewhere.
+```python
+def process_file(self, file_path: str):
+self.log(f"Processing file {file_path}")
+```
 
 ## Contribute custom components to Langflow
 
-See [How to Contribute](/contributing-components) to contribute your custom component to Langflow.
+To contribute your custom component to the Langflow project, see [Contribute components](/contributing-components).