langflow-base-nightly 0.5.0.dev37__py3-none-any.whl → 0.5.0.dev38__py3-none-any.whl

langflow/components/mem0/mem0_chat_memory.py

@@ -1,17 +1,11 @@
 import os
 
-from loguru import logger
 from mem0 import Memory, MemoryClient
 
 from langflow.base.memory.model import LCChatMemoryComponent
-from langflow.inputs.inputs import (
-    DictInput,
-    HandleInput,
-    MessageTextInput,
-    NestedDictInput,
-    SecretStrInput,
-)
+from langflow.inputs.inputs import DictInput, HandleInput, MessageTextInput, NestedDictInput, SecretStrInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 

langflow/components/nvidia/nvidia.py

@@ -1,6 +1,5 @@
 from typing import Any
 
-from loguru import logger
 from requests.exceptions import ConnectionError  # noqa: A004
 from urllib3.exceptions import MaxRetryError, NameResolutionError
 
@@ -8,6 +7,7 @@ from langflow.base.models.model import LCModelComponent
 from langflow.field_typing import LanguageModel
 from langflow.field_typing.range_spec import RangeSpec
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
+from langflow.logging.logger import logger
 from langflow.schema.dotdict import dotdict
 
 
@@ -97,7 +97,7 @@ class NVIDIAModelComponent(LCModelComponent):
         ),
     ]
 
-    def get_models(self, tool_model_enabled: bool | None = None) -> list[str]:
+    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
         try:
             from langchain_nvidia_ai_endpoints import ChatNVIDIA
         except ImportError as e:
@@ -114,7 +114,7 @@ class NVIDIAModelComponent(LCModelComponent):
     def update_build_config(self, build_config: dotdict, _field_value: Any, field_name: str | None = None):
         if field_name in {"model_name", "tool_model_enabled", "base_url", "api_key"}:
             try:
-                ids = self.get_models(self.tool_model_enabled)
+                ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
                 build_config["model_name"]["options"] = ids
 
                 if "value" not in build_config["model_name"] or build_config["model_name"]["value"] is None:

langflow/components/olivya/olivya.py

@@ -1,10 +1,10 @@
 import json
 
 import httpx
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.io import MessageTextInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -83,7 +83,7 @@ class OlivyaComponent(Component):
                 "Content-Type": "application/json",
             }
 
-            logger.info("Sending POST request with payload: %s", payload)
+            await logger.ainfo("Sending POST request with payload: %s", payload)
 
             # Send the POST request with a timeout
             async with httpx.AsyncClient() as client:
@@ -97,19 +97,19 @@ class OlivyaComponent(Component):
 
                 # Parse and return the successful response
                 response_data = response.json()
-                logger.info("Request successful: %s", response_data)
+                await logger.ainfo("Request successful: %s", response_data)
 
         except httpx.HTTPStatusError as http_err:
-            logger.exception("HTTP error occurred")
+            await logger.aexception("HTTP error occurred")
             response_data = {"error": f"HTTP error occurred: {http_err}", "response_text": response.text}
         except httpx.RequestError as req_err:
-            logger.exception("Request failed")
+            await logger.aexception("Request failed")
             response_data = {"error": f"Request failed: {req_err}"}
         except json.JSONDecodeError as json_err:
-            logger.exception("Response parsing failed")
+            await logger.aexception("Response parsing failed")
             response_data = {"error": f"Response parsing failed: {json_err}", "raw_response": response.text}
         except Exception as e:  # noqa: BLE001
-            logger.exception("An unexpected error occurred")
+            await logger.aexception("An unexpected error occurred")
             response_data = {"error": f"An unexpected error occurred: {e!s}"}
 
         # Return the response as part of the output

langflow/components/ollama/ollama.py

@@ -245,11 +245,13 @@ class ChatOllamaComponent(LCModelComponent):
         if field_name in {"model_name", "base_url", "tool_model_enabled"}:
             if await self.is_valid_ollama_url(self.base_url):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
-                build_config["model_name"]["options"] = await self.get_models(self.base_url, tool_model_enabled)
+                build_config["model_name"]["options"] = await self.get_models(
+                    self.base_url, tool_model_enabled=tool_model_enabled
+                )
             elif await self.is_valid_ollama_url(build_config["base_url"].get("value", "")):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
                 build_config["model_name"]["options"] = await self.get_models(
-                    build_config["base_url"].get("value", ""), tool_model_enabled
+                    build_config["base_url"].get("value", ""), tool_model_enabled=tool_model_enabled
                 )
             else:
                 build_config["model_name"]["options"] = []
@@ -265,7 +267,7 @@ class ChatOllamaComponent(LCModelComponent):
 
         return build_config
 
-    async def get_models(self, base_url_value: str, tool_model_enabled: bool | None = None) -> list[str]:
+    async def get_models(self, base_url_value: str, *, tool_model_enabled: bool | None = None) -> list[str]:
         """Fetches a list of models from the Ollama API that do not have the "embedding" capability.
 
         Args:
@@ -298,13 +300,13 @@ class ChatOllamaComponent(LCModelComponent):
                 models = tags_response.json()
                 if asyncio.iscoroutine(models):
                     models = await models
-                logger.debug(f"Available models: {models}")
+                await logger.adebug(f"Available models: {models}")
 
                 # Filter models that are NOT embedding models
                 model_ids = []
                 for model in models[self.JSON_MODELS_KEY]:
                     model_name = model[self.JSON_NAME_KEY]
-                    logger.debug(f"Checking model: {model_name}")
+                    await logger.adebug(f"Checking model: {model_name}")
 
                     payload = {"model": model_name}
                     show_response = await client.post(show_url, json=payload)
@@ -313,7 +315,7 @@ class ChatOllamaComponent(LCModelComponent):
                     if asyncio.iscoroutine(json_data):
                         json_data = await json_data
                     capabilities = json_data.get(self.JSON_CAPABILITIES_KEY, [])
-                    logger.debug(f"Model: {model_name}, Capabilities: {capabilities}")
+                    await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
 
                     if self.DESIRED_CAPABILITY in capabilities and (
                         not tool_model_enabled or self.TOOL_CALLING_CAPABILITY in capabilities

langflow/components/processing/batch_run.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, cast
 
 import toml  # type: ignore[import-untyped]
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 
 if TYPE_CHECKING:
@@ -144,11 +144,11 @@ class BatchRunComponent(Component):
                 user_texts = df[col_name].astype(str).tolist()
             else:
                 user_texts = [
-                    self._format_row_as_toml(cast(dict[str, Any], row)) for row in df.to_dict(orient="records")
+                    self._format_row_as_toml(cast("dict[str, Any]", row)) for row in df.to_dict(orient="records")
                 ]
 
             total_rows = len(user_texts)
-            logger.info(f"Processing {total_rows} rows with batch run")
+            await logger.ainfo(f"Processing {total_rows} rows with batch run")
 
             # Prepare the batch of conversations
             conversations = [
@@ -185,21 +185,21 @@ class BatchRunComponent(Component):
             ):
                 response_text = response[1].content if hasattr(response[1], "content") else str(response[1])
                 row = self._create_base_row(
-                    cast(dict[str, Any], original_row), model_response=response_text, batch_index=idx
+                    cast("dict[str, Any]", original_row), model_response=response_text, batch_index=idx
                 )
                 self._add_metadata(row, success=True, system_msg=system_msg)
                 rows.append(row)
 
                 # Log progress
                 if (idx + 1) % max(1, total_rows // 10) == 0:
-                    logger.info(f"Processed {idx + 1}/{total_rows} rows")
+                    await logger.ainfo(f"Processed {idx + 1}/{total_rows} rows")
 
-            logger.info("Batch processing completed successfully")
+            await logger.ainfo("Batch processing completed successfully")
             return DataFrame(rows)
 
         except (KeyError, AttributeError) as e:
             # Handle data structure and attribute access errors
-            logger.error(f"Data processing error: {e!s}")
-            error_row = self._create_base_row({col: "" for col in df.columns}, model_response="", batch_index=-1)
+            await logger.aerror(f"Data processing error: {e!s}")
+            error_row = self._create_base_row(dict.fromkeys(df.columns, ""), model_response="", batch_index=-1)
             self._add_metadata(error_row, success=False, error=str(e))
             return DataFrame([error_row])

langflow/components/processing/data_operations.py

@@ -181,7 +181,7 @@ class DataOperationsComponent(Component):
         raise ValueError(msg)
 
     # Data transformation operations
-    def select_keys(self, evaluate: bool | None = None) -> Data:
+    def select_keys(self, *, evaluate: bool | None = None) -> Data:
         """Select specific keys from the data dictionary."""
         self.validate_single_data("Select Keys")
         data_dict = self.get_normalized_data()
@@ -266,7 +266,7 @@ class DataOperationsComponent(Component):
         logger.info("evaluating data")
         return Data(**self.recursive_eval(self.get_data_dict()))
 
-    def combine_data(self, evaluate: bool | None = None) -> Data:
+    def combine_data(self, *, evaluate: bool | None = None) -> Data:
         """Combine multiple data objects into one."""
         logger.info("combining data")
         if not self.data_is_list():

langflow/components/processing/merge_data.py

@@ -1,10 +1,9 @@
 from enum import Enum
 from typing import cast
 
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.io import DataInput, DropdownInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 
 

langflow/components/processing/message_to_data.py

@@ -1,7 +1,6 @@
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.io import MessageInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 
@@ -32,6 +31,6 @@ class MessageToDataComponent(Component):
             return Data(data=self.message.data)
 
         msg = "Error converting Message to Data: Input must be a Message object"
-        logger.opt(exception=True).debug(msg)
+        logger.debug(msg, exc_info=True)
         self.status = msg
         return Data(data={"error": msg})

langflow/components/processing/parse_json_data.py

@@ -3,11 +3,11 @@ from json import JSONDecodeError
 
 import jq
 from json_repair import repair_json
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import HandleInput, MessageTextInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

langflow/components/prototypes/python_function.py

@@ -1,10 +1,9 @@
 from collections.abc import Callable
 
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.custom.utils import get_function
 from langflow.io import CodeInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 from langflow.schema.message import Message
@@ -58,7 +57,7 @@ class PythonFunctionComponent(Component):
             func = get_function(function_code)
             return func()
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error executing function")
+            logger.debug("Error executing function", exc_info=True)
             return f"Error executing function: {e}"
 
     def execute_function_data(self) -> list[Data]:

langflow/components/serpapi/serp.py

@@ -2,12 +2,12 @@ from typing import Any
 
 from langchain_community.utilities.serpapi import SerpAPIWrapper
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

langflow/components/tavily/tavily_extract.py

@@ -1,8 +1,8 @@
 import httpx
-from loguru import logger
 
 from langflow.custom import Component
 from langflow.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema import Data
 from langflow.schema.dataframe import DataFrame
 

langflow/components/tavily/tavily_search.py

@@ -1,8 +1,8 @@
 import httpx
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 from langflow.template.field.base import Output

langflow/components/tools/calculator.py

@@ -3,12 +3,12 @@ import operator
 
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import MessageTextInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -87,7 +87,7 @@ class CalculatorToolComponent(LCToolComponent):
             self.status = error_message
             return [Data(data={"error": error_message, "input": expression})]
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error evaluating expression")
+            logger.debug("Error evaluating expression", exc_info=True)
             error_message = f"Error: {e}"
             self.status = error_message
             return [Data(data={"error": error_message, "input": expression})]

langflow/components/tools/python_code_structured_tool.py

@@ -4,21 +4,14 @@ from typing import Any
 
 from langchain.agents import Tool
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from pydantic.v1 import Field, create_model
 from pydantic.v1.fields import Undefined
 from typing_extensions import override
 
 from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.inputs.inputs import (
-    BoolInput,
-    DropdownInput,
-    FieldTypes,
-    HandleInput,
-    MessageTextInput,
-    MultilineInput,
-)
+from langflow.inputs.inputs import BoolInput, DropdownInput, FieldTypes, HandleInput, MessageTextInput, MultilineInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 
@@ -139,7 +132,7 @@ class PythonCodeStructuredTool(LCToolComponent):
             build_config["tool_function"]["options"] = names
         except Exception as e:  # noqa: BLE001
             self.status = f"Failed to extract names: {e}"
-            logger.opt(exception=True).debug(self.status)
+            logger.debug(self.status, exc_info=True)
             build_config["tool_function"]["options"] = ["Failed to parse", str(e)]
         return build_config
 

langflow/components/tools/python_repl.py

@@ -3,12 +3,12 @@ import importlib
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
 from langchain_experimental.utilities import PythonREPL
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import StrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -78,7 +78,7 @@ class PythonREPLToolComponent(LCToolComponent):
             try:
                 return python_repl.run(code)
             except Exception as e:
-                logger.opt(exception=True).debug("Error running Python code")
+                logger.debug("Error running Python code", exc_info=True)
                 raise ToolException(str(e)) from e
 
         tool = StructuredTool.from_function(

langflow/components/tools/searxng.py

@@ -5,12 +5,12 @@ from typing import Any
 import requests
 from langchain.agents import Tool
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from pydantic.v1 import Field, create_model
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput, MultiselectInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.dotdict import dotdict
 
 
@@ -76,7 +76,7 @@ class SearXNGToolComponent(LCToolComponent):
             build_config["language"]["options"] = languages.copy()
         except Exception as e:  # noqa: BLE001
             self.status = f"Failed to extract names: {e}"
-            logger.opt(exception=True).debug(self.status)
+            logger.debug(self.status, exc_info=True)
             build_config["categories"]["options"] = ["Failed to parse", str(e)]
         return build_config
 
@@ -112,7 +112,7 @@ class SearXNGToolComponent(LCToolComponent):
                     num_results = min(SearxSearch._max_results, len(response["results"]))
                     return [response["results"][i] for i in range(num_results)]
                 except Exception as e:  # noqa: BLE001
-                    logger.opt(exception=True).debug("Error running SearXNG Search")
+                    logger.debug("Error running SearXNG Search", exc_info=True)
                     return [f"Failed to search: {e}"]
 
         SearxSearch._url = self.url

langflow/components/tools/serp_api.py

@@ -3,12 +3,12 @@ from typing import Any
 from langchain.tools import StructuredTool
 from langchain_community.utilities.serpapi import SerpAPIWrapper
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -111,7 +111,7 @@ class SerpAPIComponent(LCToolComponent):
             data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
 
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error running SerpAPI")
+            logger.debug("Error running SerpAPI", exc_info=True)
             self.status = f"Error: {e}"
             return [Data(data={"error": str(e)}, text=str(e))]
 

langflow/components/tools/tavily_search_tool.py

@@ -3,12 +3,12 @@ from enum import Enum
 import httpx
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 # Add at the top with other constants
@@ -338,7 +338,7 @@ Note: Check 'Advanced' for all options.
             raise ToolException(error_message) from e
         except Exception as e:
             error_message = f"Unexpected error: {e}"
-            logger.opt(exception=True).debug("Error running Tavily Search")
+            logger.debug("Error running Tavily Search", exc_info=True)
             self.status = error_message
             raise ToolException(error_message) from e
         return data_results

langflow/components/tools/yahoo_finance.py

@@ -5,12 +5,12 @@ from enum import Enum
 import yfinance as yf
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 

langflow/components/twelvelabs/video_embeddings.py

@@ -29,9 +29,9 @@ class TwelveLabsVideoEmbeddings(Embeddings):
 
             # First try to use video embedding, then fall back to clip embedding if available
             if result["video_embedding"] is not None:
-                embeddings.append(cast(list[float], result["video_embedding"]))
+                embeddings.append(cast("list[float]", result["video_embedding"]))
             elif result["clip_embeddings"] and len(result["clip_embeddings"]) > 0:
-                embeddings.append(cast(list[float], result["clip_embeddings"][0]))
+                embeddings.append(cast("list[float]", result["clip_embeddings"][0]))
             else:
                 # If neither is available, raise an error
                 error_msg = "No embeddings were generated for the video"
@@ -45,9 +45,9 @@ class TwelveLabsVideoEmbeddings(Embeddings):
 
         # First try to use video embedding, then fall back to clip embedding if available
         if result["video_embedding"] is not None:
-            return cast(list[float], result["video_embedding"])
+            return cast("list[float]", result["video_embedding"])
         if result["clip_embeddings"] and len(result["clip_embeddings"]) > 0:
-            return cast(list[float], result["clip_embeddings"][0])
+            return cast("list[float]", result["clip_embeddings"][0])
         # If neither is available, raise an error
         error_msg = "No embeddings were generated for the video"
         raise ValueError(error_msg)

langflow/components/vectorstores/local_db.py

@@ -2,13 +2,13 @@ from copy import deepcopy
 from pathlib import Path
 
 from langchain_chroma import Chroma
-from loguru import logger
 from typing_extensions import override
 
 from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
 from langflow.base.vectorstores.utils import chroma_collection_to_data
 from langflow.inputs.inputs import MultilineInput
 from langflow.io import BoolInput, DropdownInput, HandleInput, IntInput, MessageTextInput, TabInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 from langflow.template.field.base import Output

langflow/components/yahoosearch/yahoo.py

@@ -4,12 +4,12 @@ from enum import Enum
 
 import yfinance as yf
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 

langflow/components/youtube/trending.py

@@ -6,6 +6,7 @@ from googleapiclient.errors import HttpError
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 from langflow.template.field.base import Output
 
@@ -279,8 +280,6 @@ class YouTubeTrendingComponent(Component):
 
             return DataFrame(pd.DataFrame({"error": [error_message]}))
 
-        except Exception as e:
-            import logging
-
-            logging.exception("An unexpected error occurred:")
+        except Exception as e:  # noqa: BLE001
+            logger.exception("An unexpected error occurred:")
             return DataFrame(pd.DataFrame({"error": [str(e)]}))

langflow/custom/attributes.py

@@ -1,7 +1,8 @@
 from collections.abc import Callable
 
 import emoji
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 
 def validate_icon(value: str):

langflow/custom/code_parser/code_parser.py

@@ -8,10 +8,10 @@ from typing import Any
 
 from cachetools import TTLCache, keys
 from fastapi import HTTPException
-from loguru import logger
 
 from langflow.custom.eval import eval_custom_component_code
 from langflow.custom.schema import CallableCodeDetails, ClassCodeDetails, MissingDefault
+from langflow.logging.logger import logger
 
 
 class CodeSyntaxError(HTTPException):

langflow/custom/custom_component/base_component.py

@@ -5,11 +5,11 @@ from typing import TYPE_CHECKING, Any, ClassVar
 
 from cachetools import TTLCache, cachedmethod
 from fastapi import HTTPException
-from loguru import logger
 
 from langflow.custom.attributes import ATTR_FUNC_MAPPING
 from langflow.custom.code_parser.code_parser import CodeParser
 from langflow.custom.eval import eval_custom_component_code
+from langflow.logging.logger import logger
 from langflow.utils import validate
 
 if TYPE_CHECKING:

langflow/custom/custom_component/component.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import ast
 import asyncio
 import inspect
+import json
 from collections.abc import AsyncIterator, Iterator
 from copy import deepcopy
 from textwrap import dedent
@@ -1019,10 +1020,23 @@ class Component(CustomComponent):
         return {**predefined_inputs, **runtime_inputs}
 
     def get_trace_as_metadata(self):
+        def safe_list_values(items):
+            return [v if isinstance(v, str | int | float | bool) or v is None else str(v) for v in items]
+
+        def safe_value(val):
+            if isinstance(val, str | int | float | bool) or val is None:
+                return val
+            if isinstance(val, list | tuple):
+                return safe_list_values(val)
+            try:
+                return json.dumps(val)
+            except (TypeError, ValueError):
+                return str(val)
+
         return {
-            input_.name: input_.value
+            input_.name: safe_value(getattr(self, input_.name, input_.value))
             for input_ in self.inputs
-            if hasattr(input_, "trace_as_metadata") and input_.trace_as_metadata
+            if getattr(input_, "trace_as_metadata", False)
         }
 
     async def _build_with_tracing(self):