Custom Component, Frozen, running flow forever

[levalencia]

I am writing a custom component to search in Azure AI Search, however when running in the playground, it stays there running forever, with no message writen to the chat output.
Whats going on?

from typing import Dict, Any
from langflow import CustomComponent
from azure.search.documents import SearchClient
from azure.core.credentials import AzureKeyCredential
from langflow.schema.message import Message
from langflow.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI
import concurrent.futures
import time

class AzureSearchSimpleTest(CustomComponent):
    display_name: str = "Azure Search Test"
    description: str = "Tests Azure Search connectivity and shows errors immediately"

    def build_config(self) -> Dict[str, Any]:
        return {
            "message": {
                "display_name": "Search Query",
                "type": "Message",
                "required": True
            },
            "azure_search_endpoint": {
                "display_name": "Azure Search Endpoint",
                "type": "str",
                "required": True
            },
            "azure_search_key": {
                "display_name": "Azure Search Key",
                "type": "str",
                "required": True,
                "password": True
            },
            "azure_search_index": {
                "display_name": "Azure Search Index",
                "type": "str",
                "required": True
            }
        }

    def build(self, 
             message: Message,
             azure_search_endpoint: str,
             azure_search_key: str, 
             azure_search_index: str,
             **kwargs) -> Message:
        """Quick test of Azure Search with immediate error feedback"""
        
        start_time = time.time()
        
        # Create error response function
        def create_error_message(error_text: str) -> Message:
            return Message(
                text=f"❌ Error: {error_text}\nTime: {time.time() - start_time:.2f} seconds",
                sender=MESSAGE_SENDER_AI,
                sender_name="Search Test"
            )

        try:
            # Test 1: Can we create a search client?
            try:
                search_client = SearchClient(
                    endpoint=azure_search_endpoint,
                    index_name=azure_search_index,
                    credential=AzureKeyCredential(azure_search_key)
                )
            except Exception as e:
                return create_error_message(f"Failed to initialize search client: {str(e)}")

            # Test 2: Can we execute a simple search within 3 seconds?
            with concurrent.futures.ThreadPoolExecutor() as executor:
                future = executor.submit(
                    lambda: list(search_client.search(
                        search_text="*",
                        top=1
                    ))
                )
                
                try:
                    # Wait for max 3 seconds
                    future.result(timeout=3)
                except concurrent.futures.TimeoutError:
                    return create_error_message("Search timed out after 3 seconds. Service might be unavailable.")
                except Exception as e:
                    return create_error_message(f"Search failed: {str(e)}")

            # If we got here, basic connectivity works. Try the actual search.
            query = message.text if message else "*"
            
            try:
                with concurrent.futures.ThreadPoolExecutor() as executor:
                    future = executor.submit(
                        lambda: list(search_client.search(
                            search_text=query,
                            top=5,
                            select=["chunk"]
                        ))
                    )
                    
                    results = future.result(timeout=3)
                    
                    if not results:
                        return Message(
                            text=f"✅ Connected successfully but no results found for: {query}\nTime: {time.time() - start_time:.2f} seconds",
                            sender=MESSAGE_SENDER_AI,
                            sender_name="Search Test"
                        )
                    
                    # Format results
                    result_text = "\n\n".join([
                        f"Result {i+1}:\n{r.get('chunk', 'No content')[:200]}..."  # Truncate long results
                        for i, r in enumerate(results)
                    ])
                    
                    return Message(
                        text=f"""✅ Search Successful!
Query: {query}
Time: {time.time() - start_time:.2f} seconds

{result_text}""",
                        sender=MESSAGE_SENDER_AI,
                        sender_name="Search Test"
                    )
                    
            except concurrent.futures.TimeoutError:
                return create_error_message("Search query timed out after 3 seconds")
            except Exception as e:
                return create_error_message(f"Search query failed: {str(e)}")

        except Exception as e:
            return create_error_message(f"Unexpected error: {str(e)}")

[dosubot[bot]]

The issue of your custom component running indefinitely could be due to several factors. Here are some potential causes and suggestions for diagnosing the problem:

1. Network Connectivity: Ensure that your network connection to the Azure Search service is stable. Any network issues could cause the search client to hang.

2. Timeouts: You have implemented timeouts using concurrent.futures.ThreadPoolExecutor, which is good. However, if the network call or the Azure service is not responding within the specified timeout, it should raise a TimeoutError. Make sure that the timeout is being correctly applied and that exceptions are being caught and handled as expected.

3. Error Handling: Double-check that all exceptions are being caught and logged. You have a mechanism to create error messages, but ensure that this is functioning correctly and that any exceptions are not being swallowed silently.

4. Logging: Add logging statements to track the flow of execution. This can help identify where the code is getting stuck. For example, log before and after each major operation, such as creating the search client and executing the search.

5. Thread Management: Ensure that the ThreadPoolExecutor is being used correctly and that threads are not being blocked indefinitely. You might want to test the component with a simpler operation to ensure that threading is not causing the issue.

6. Azure Service Status: Check the status of the Azure Search service to ensure it is operational and not experiencing any outages.

7. Debugging: Run the component in a local environment where you can step through the code with a debugger to see exactly where it hangs.

By following these steps, you should be able to identify the cause of the indefinite running issue and address it accordingly.

To continue talking to Dosu, mention @dosu.

[levalencia]

@dosu so the custom component code seems correct? How can I use the logs for this? I am running langflow in a dockerized environment,

[dosubot[bot]]

To diagnose issues with your custom component code in a dockerized Langflow environment, you can utilize the logging capabilities provided by the loguru logger. Here's how you can use logs effectively:

1. Check for Error Logs: Your code should include logger.error statements to log errors when exceptions occur. This will help you identify where the code might be failing.

2. Traceback Information: Ensure that any raised exceptions include traceback information, which can be logged to understand the sequence of calls leading to the error.

3. View Docker Logs: Use the docker logs command to view logs from your Langflow container. For example, if your container is named langflow, run:

   docker logs langflow

4. Set Logging Level: Use Langflow's CLI options to specify the logging level. You can set it to debug for more detailed logs using the --log-level option or the LANGFLOW_LOG_LEVEL environment variable.

5. Log File Path: Optionally, specify a log file path using the --log-file option or the LANGFLOW_LOG_FILE environment variable to store logs persistently.

By reviewing these logs, you can gain insights into where your custom component might be encountering issues ^[1][2].

To continue talking to Dosu, mention @dosu.

[anovazzi1]

hey, can you please create an issue for that bug?