Implement logging

[SVyusti]

How can I implement component logging in langflow==0.6.19?

[dosubot[bot]]

To implement component logging in langflow==0.6.19, you can use the configure function from the src/backend/langflow/utils/logger.py file. This function sets up logging using the loguru library and integrates it with RichHandler for enhanced log formatting.

Here is an example of how you can configure logging in your component:

from pathlib import Path
from langflow.utils.logger import configure

# Configure logging with optional log level and log file path
configure(log_level="DEBUG", log_file=Path("/path/to/your/logfile.log"))

# Now you can use the logger in your component
from loguru import logger

logger.info("This is an info message")
logger.debug("This is a debug message")
logger.error("This is an error message")

This setup will log messages to both the console and a specified log file, with log rotation based on file size (10 MB). The log level can be adjusted as needed, and the log format is designed to be human-readable.

For a practical example of logging within a component, you can refer to the SubFlowComponent class in src/backend/base/langflow/components/deactivated/SubFlow.py. This class uses the loguru logger to log various debug and error messages:

from loguru import logger

class SubFlowComponent(CustomComponent):
    display_name = "Sub Flow"
    description = (
        "Dynamically Generates a Component from a Flow. The output is a list of data with keys 'result' and 'message'."
    )
    beta: bool = True
    field_order = ["flow_name"]

    def get_flow_names(self) -> List[str]:
        flow_datas = self.list_flows()
        return [flow_data.data["name"] for flow_data in flow_datas]

    def get_flow(self, flow_name: str) -> Optional[Data]:
        flow_datas = self.list_flows()
        for flow_data in flow_datas:
            if flow_data.data["name"] == flow_name:
                return flow_data
        return None

    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
        logger.debug(f"Updating build config with field value {field_value} and field name {field_name}")
        if field_name == "flow_name":
            build_config["flow_name"]["options"] = self.get_flow_names()
        # Clean up the build config
        for key in list(build_config.keys()):
            if key not in self.field_order + ["code", "_type", "get_final_results_only"]:
                del build_config[key]
        if field_value is not None and field_name == "flow_name":
            try:
                flow_data = self.get_flow(field_value)
                if not flow_data:
                    raise ValueError(f"Flow {field_value} not found.")
                graph = Graph.from_payload(flow_data.data["data"])
                # Get all inputs from the graph
                inputs = get_flow_inputs(graph)
                # Add inputs to the build config
                build_config = self.add_inputs_to_build_config(inputs, build_config)
            except Exception as e:
                logger.error(f"Error getting flow {field_value}: {str(e)}")

        return build_config

    def add_inputs_to_build_config(self, inputs: List[Vertex], build_config: dotdict):
        new_fields: list[Input] = []
        for vertex in inputs:
            field = Input(
                display_name=vertex.display_name,
                name=vertex.id,
                info=vertex.description,
                field_type="str",
                value=None,
            )
            new_fields.append(field)
        logger.debug(new_fields)
        for field in new_fields:
            build_config[field.name] = field.to_dict()
        return build_config

    def build_config(self):
        return {
            "input_value": {
                "display_name": "Input Value",
                "multiline": True,
            },
            "flow_name": {
                "display_name": "Flow Name",
                "info": "The name of the flow to run.",
                "options": [],
                "real_time_refresh": True,
                "refresh_button": True,
            },
            "tweaks": {
                "display_name": "Tweaks",
                "info": "Tweaks to apply to the flow.",
            },
            "get_final_results_only": {
                "display_name": "Get Final Results Only",
                "info": "If False, the output will contain all outputs from the flow.",
                "advanced": True,
            },
        }

    async def build(self, flow_name: str, get_final_results_only: bool = True, **kwargs) -> List[Data]:
        tweaks = {key: {"input_value": value} for key, value in kwargs.items()}
        run_outputs: List[Optional[RunOutputs]] = await self.run_flow(
            tweaks=tweaks,
            flow_name=flow_name,
        )
        if not run_outputs:
            return []
        run_output = run_outputs[0]

        data = []
        if run_output is not None:
            for output in run_output.outputs:
                if output:
                    data.extend(build_data_from_result_data(output, get_final_results_only))
        self.status = data
        logger.debug(data)
        return data

This ensures that all logging is consistent and properly formatted across different parts of your application ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.

[dosubot[bot]]

To write the logs into a langflow.log file in langflow==0.6.19, you can use the configure function provided in the logger.py file. Here is how you can do it:

from pathlib import Path
from langflow.utils.logger import configure

# Set the log file path
log_file_path = Path("path/to/your/langflow.log")

# Configure the logger
configure(log_file=log_file_path)

This will set up the logging to write all logs to the specified langflow.log file. Make sure to replace "path/to/your/langflow.log" with the actual path where you want the log file to be created. The configure function also handles log rotation based on file size and ensures that the log directory is created if it does not exist ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

Can I put this code at a higher level, such that all components would write the logs in the file. @dosu

[dosubot[bot]]

Yes, you can configure logging at a higher level so that all components write logs to a langflow.log file. You can do this by placing the logging configuration code in a central location that is executed when your application starts. Here is an example of how you can achieve this:

1. Create a logging configuration file (e.g., logging_config.py):

from pathlib import Path
from langflow.utils.logger import configure

# Set the log level and log file path
log_level = "DEBUG"  # or any other level from ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
log_file = Path("path/to/your/langflow.log")

# Configure the logger
configure(log_level=log_level, log_file=log_file)

2. Import and execute the logging configuration at the entry point of your application:

For example, if your main application file is main.py, you can import the logging configuration at the top of this file:

# main.py
import logging_config  # This will execute the logging configuration

# Your application code here
from loguru import logger

logger.info("Application started")
# Rest of your application code

By doing this, the logging configuration will be applied globally, and all components will write logs to the specified langflow.log file with the desired log level ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

on langflow run , logs/langflow.log is created but no logs are written in it. I'm using langflow version==0.6.19

[dosubot[bot]]

To ensure that logs are properly written to the logs/langflow.log file when using langflow==0.6.19, you need to call the configure function with the appropriate log_file parameter. Here is an example of how to do this:

from pathlib import Path
from langflow.utils.logger import configure

# Ensure the logs directory exists
log_file_path = Path("logs/langflow.log")
log_file_path.parent.mkdir(parents=True, exist_ok=True)

# Configure the logger
configure(log_file=log_file_path)

This code snippet ensures that the logs directory exists and then configures the logger to write logs to logs/langflow.log. The configure function will handle the rest, including setting up log rotation and serialization ^[1][2].

If you have already done this and the logs are still not being written, there might be a known issue in langflow==0.6.19 related to logging. Specifically, if an exception occurs while setting up the log file, it is caught and logged as an error, but the logging to the specified file will not be set up correctly. This can prevent logs from being written to the specified file ^[1][2].

Additionally, ensure that the required versions of the loguru and rich libraries are installed, as specified in the pyproject.toml file:

loguru = "^0.7.1"
rich = "^13.7.0"

These versions are necessary for the logging functionality to work correctly ^[3].

Lastly, if you are running on macOS, make sure to set the environment variable OBJC_DISABLE_INITIALIZE_FORK_SAFETY to "YES" to avoid errors that could affect logging:

import os
import platform

if platform.system() == "Darwin":
    os.environ["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"] = "YES"

This should help ensure that logs are properly written to the logs/langflow.log file.

To continue talking to Dosu, mention @dosu.

[SnakeO]

@dosu no module named langflow.utils.logger

[ravishulthanmekari]

Is this solved yet?