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

langflow/services/store/service.py

@@ -6,8 +6,8 @@ from uuid import UUID
 
 import httpx
 from httpx import HTTPError, HTTPStatusError
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.store.exceptions import APIKeyError, FilterError, ForbiddenError
 from langflow.services.store.schema import (
@@ -162,7 +162,7 @@ class StoreService(Service):
         except HTTPError:
             raise
         except Exception:  # noqa: BLE001
-            logger.opt(exception=True).debug("Webhook failed")
+            logger.debug("Webhook failed", exc_info=True)
 
     @staticmethod
     def build_tags_filter(tags: list[str]):
@@ -594,7 +594,7 @@ class StoreService(Service):
                         authorized = True
                         result = updated_result
                     except Exception:  # noqa: BLE001
-                        logger.opt(exception=True).debug("Error updating components with user data")
+                        logger.debug("Error updating components with user data", exc_info=True)
                         # If we get an error here, it means the user is not authorized
                         authorized = False
         return ListComponentResponseModel(results=result, authorized=authorized, count=comp_count)

langflow/services/store/utils.py

@@ -1,7 +1,8 @@
 from typing import TYPE_CHECKING
 
 import httpx
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 if TYPE_CHECKING:
     from langflow.services.store.schema import ListComponentResponse
@@ -49,7 +50,7 @@ async def get_lf_version_from_pypi():
             return None
         return response.json()["info"]["version"]
     except Exception:  # noqa: BLE001
-        logger.opt(exception=True).debug("Error getting the latest version of langflow from PyPI")
+        logger.debug("Error getting the latest version of langflow from PyPI", exc_info=True)
         return None
 
 

langflow/services/task/temp_flow_cleanup.py

@@ -4,9 +4,9 @@ import asyncio
 import contextlib
 from typing import TYPE_CHECKING
 
-from loguru import logger
 from sqlmodel import col, delete, select
 
+from langflow.logging.logger import logger
 from langflow.services.database.models.message.model import MessageTable
 from langflow.services.database.models.transactions.model import TransactionTable
 from langflow.services.database.models.vertex_builds.model import VertexBuildTable
@@ -79,23 +79,23 @@ class CleanupWorker:
     async def start(self):
         """Start the cleanup worker."""
         if self._task is not None:
-            logger.warning("Cleanup worker is already running")
+            await logger.awarning("Cleanup worker is already running")
             return
 
         self._task = asyncio.create_task(self._run())
-        logger.debug("Started database cleanup worker")
+        await logger.adebug("Started database cleanup worker")
 
     async def stop(self):
         """Stop the cleanup worker gracefully."""
         if self._task is None:
-            logger.warning("Cleanup worker is not running")
+            await logger.awarning("Cleanup worker is not running")
             return
 
-        logger.debug("Stopping database cleanup worker...")
+        await logger.adebug("Stopping database cleanup worker...")
         self._stop_event.set()
         await self._task
         self._task = None
-        logger.debug("Database cleanup worker stopped")
+        await logger.adebug("Database cleanup worker stopped")
 
     async def _run(self):
         """Run the cleanup worker until stopped."""
@@ -105,7 +105,7 @@ class CleanupWorker:
                 # Clean up any orphaned records
                 await cleanup_orphaned_records()
             except Exception as exc:  # noqa: BLE001
-                logger.error(f"Error in cleanup worker: {exc!s}")
+                await logger.aerror(f"Error in cleanup worker: {exc!s}")
 
             try:
                 # Create a task for the timeout

langflow/services/telemetry/service.py

@@ -9,8 +9,8 @@ from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 import httpx
-from loguru import logger
 
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.telemetry.opentelemetry import OpenTelemetry
 from langflow.services.telemetry.schema import (
@@ -56,13 +56,13 @@ class TelemetryService(Service):
             try:
                 await func(payload, path)
             except Exception:  # noqa: BLE001
-                logger.error("Error sending telemetry data")
+                await logger.aerror("Error sending telemetry data")
             finally:
                 self.telemetry_queue.task_done()
 
     async def send_telemetry_data(self, payload: BaseModel, path: str | None = None) -> None:
         if self.do_not_track:
-            logger.debug("Telemetry tracking is disabled.")
+            await logger.adebug("Telemetry tracking is disabled.")
             return
 
         url = f"{self.base_url}"
@@ -73,15 +73,15 @@ class TelemetryService(Service):
             payload_dict = payload.model_dump(by_alias=True, exclude_none=True, exclude_unset=True)
             response = await self.client.get(url, params=payload_dict)
             if response.status_code != httpx.codes.OK:
-                logger.error(f"Failed to send telemetry data: {response.status_code} {response.text}")
+                await logger.aerror(f"Failed to send telemetry data: {response.status_code} {response.text}")
             else:
-                logger.debug("Telemetry data sent successfully.")
+                await logger.adebug("Telemetry data sent successfully.")
         except httpx.HTTPStatusError:
-            logger.error("HTTP error occurred")
+            await logger.aerror("HTTP error occurred")
         except httpx.RequestError:
-            logger.error("Request error occurred")
+            await logger.aerror("Request error occurred")
         except Exception:  # noqa: BLE001
-            logger.error("Unexpected error occurred")
+            await logger.aerror("Unexpected error occurred")
 
     async def log_package_run(self, payload: RunPayload) -> None:
         await self._queue_event((self.send_telemetry_data, payload, "run"))
@@ -161,7 +161,7 @@ class TelemetryService(Service):
         try:
             await self.telemetry_queue.join()
         except Exception:  # noqa: BLE001
-            logger.exception("Error flushing logs")
+            await logger.aexception("Error flushing logs")
 
     @staticmethod
     async def _cancel_task(task: asyncio.Task, cancel_msg: str) -> None:
@@ -186,7 +186,7 @@ class TelemetryService(Service):
                 await self._cancel_task(self.log_package_version_task, "Cancel telemetry log package version task")
             await self.client.aclose()
         except Exception:  # noqa: BLE001
-            logger.exception("Error stopping tracing service")
+            await logger.aexception("Error stopping tracing service")
 
     async def teardown(self) -> None:
         await self.stop()

langflow/services/tracing/arize_phoenix.py

@@ -10,13 +10,13 @@ from typing import TYPE_CHECKING, Any
 
 from langchain_core.documents import Document
 from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
-from loguru import logger
 from openinference.semconv.trace import OpenInferenceMimeTypeValues, SpanAttributes
 from opentelemetry.semconv.trace import SpanAttributes as OTELSpanAttributes
 from opentelemetry.trace import Span, Status, StatusCode, use_span
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 from langflow.services.tracing.base import BaseTracer
@@ -78,7 +78,7 @@ class ArizePhoenixTracer(BaseTracer):
             self.child_spans: dict[str, Span] = {}
 
         except Exception:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error setting up Arize/Phoenix tracer")
+            logger.debug("Error setting up Arize/Phoenix tracer", exc_info=True)
             self._ready = False
 
     @property

langflow/services/tracing/langfuse.py

@@ -5,9 +5,9 @@ from collections import OrderedDict
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.serialization.serialization import serialize
 from langflow.services.tracing.base import BaseTracer
 

langflow/services/tracing/langsmith.py

@@ -6,9 +6,9 @@ import types
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.serialization.serialization import serialize
 from langflow.services.tracing.base import BaseTracer

langflow/services/tracing/langwatch.py

@@ -4,9 +4,9 @@ import os
 from typing import TYPE_CHECKING, Any, cast
 
 import nanoid
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.services.tracing.base import BaseTracer
 

langflow/services/tracing/opik.py

@@ -6,9 +6,9 @@ from typing import TYPE_CHECKING, Any
 
 from langchain_core.documents import Document
 from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 from langflow.services.tracing.base import BaseTracer

langflow/services/tracing/service.py

@@ -7,8 +7,7 @@ from contextlib import asynccontextmanager
 from contextvars import ContextVar
 from typing import TYPE_CHECKING, Any
 
-from loguru import logger
-
+from langflow.logging.logger import logger
 from langflow.services.base import Service
 
 if TYPE_CHECKING:
@@ -53,6 +52,12 @@ def _get_opik_tracer():
     return OpikTracer
 
 
+def _get_traceloop_tracer():
+    from langflow.services.tracing.traceloop import TraceloopTracer
+
+    return TraceloopTracer
+
+
 trace_context_var: ContextVar[TraceContext | None] = ContextVar("trace_context", default=None)
 component_context_var: ContextVar[ComponentTraceContext | None] = ContextVar("component_trace_context", default=None)
 
@@ -127,7 +132,7 @@ class TracingService(Service):
             try:
                 trace_func(*args)
             except Exception:  # noqa: BLE001
-                logger.exception("Error processing trace_func")
+                await logger.aexception("Error processing trace_func")
             finally:
                 trace_context.traces_queue.task_done()
 
@@ -138,7 +143,7 @@ class TracingService(Service):
             trace_context.running = True
             trace_context.worker_task = asyncio.create_task(self._trace_worker(trace_context))
         except Exception:  # noqa: BLE001
-            logger.exception("Error starting tracing service")
+            await logger.aexception("Error starting tracing service")
 
     def _initialize_langsmith_tracer(self, trace_context: TraceContext) -> None:
         langsmith_tracer = _get_langsmith_tracer()
@@ -201,6 +206,19 @@ class TracingService(Service):
             session_id=trace_context.session_id,
         )
 
+    def _initialize_traceloop_tracer(self, trace_context: TraceContext) -> None:
+        if self.deactivated:
+            return
+        traceloop_tracer = _get_traceloop_tracer()
+        trace_context.tracers["traceloop"] = traceloop_tracer(
+            trace_name=trace_context.run_name,
+            trace_type="chain",
+            project_name=trace_context.project_name,
+            trace_id=trace_context.run_id,
+            user_id=trace_context.user_id,
+            session_id=trace_context.session_id,
+        )
+
     async def start_tracers(
         self,
         run_id: UUID,
@@ -227,8 +245,9 @@ class TracingService(Service):
             self._initialize_langfuse_tracer(trace_context)
             self._initialize_arize_phoenix_tracer(trace_context)
             self._initialize_opik_tracer(trace_context)
+            self._initialize_traceloop_tracer(trace_context)
         except Exception as e:  # noqa: BLE001
-            logger.debug(f"Error initializing tracers: {e}")
+            await logger.adebug(f"Error initializing tracers: {e}")
 
     async def _stop(self, trace_context: TraceContext) -> None:
         try:
@@ -241,7 +260,7 @@ class TracingService(Service):
                 trace_context.worker_task = None
 
         except Exception:  # noqa: BLE001
-            logger.exception("Error stopping tracing service")
+            await logger.aexception("Error stopping tracing service")
 
     def _end_all_tracers(self, trace_context: TraceContext, outputs: dict, error: Exception | None = None) -> None:
         for tracer in trace_context.tracers.values():

langflow/services/tracing/traceloop.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import json
+import math
+import os
+import types
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse
+
+from loguru import logger
+from opentelemetry import trace
+from opentelemetry.trace import Span, use_span
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+from traceloop.sdk import Traceloop
+from traceloop.sdk.instruments import Instruments
+from typing_extensions import override
+
+from langflow.services.tracing.base import BaseTracer
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from uuid import UUID
+
+    from langchain.callbacks.base import BaseCallbackHandler
+    from opentelemetry.propagators.textmap import CarrierT
+    from opentelemetry.trace import Span
+
+    from langflow.graph.vertex.base import Vertex
+    from langflow.services.tracing.schema import Log
+
+
+class TraceloopTracer(BaseTracer):
+    """Traceloop tracer for Langflow."""
+
+    def __init__(
+        self,
+        trace_name: str,
+        trace_type: str,
+        project_name: str,
+        trace_id: UUID,
+        user_id: str | None = None,
+        session_id: str | None = None,
+    ):
+        self.trace_id = trace_id
+        self.trace_name = trace_name
+        self.trace_type = trace_type
+        self.project_name = project_name
+        self.user_id = user_id
+        self.session_id = session_id
+        self.child_spans: dict[str, Span] = {}
+
+        if not self._validate_configuration():
+            self._ready = False
+            return
+
+        api_key = os.getenv("TRACELOOP_API_KEY", "").strip()
+        try:
+            Traceloop.init(
+                block_instruments={Instruments.PYMYSQL},
+                app_name=project_name,
+                disable_batch=True,
+                api_key=api_key,
+                api_endpoint=os.getenv("TRACELOOP_BASE_URL", "https://api.traceloop.com"),
+            )
+            self._ready = True
+            self._tracer = trace.get_tracer("langflow")
+            self.propagator = TraceContextTextMapPropagator()
+            self.carrier: CarrierT = {}
+
+            self.root_span = self._tracer.start_span(
+                name=trace_name,
+                start_time=self._get_current_timestamp(),
+            )
+
+            with use_span(self.root_span, end_on_exit=False):
+                self.propagator.inject(carrier=self.carrier)
+
+        except Exception:  # noqa: BLE001
+            logger.opt(exception=True).debug("Error setting up Traceloop tracer")
+            self._ready = False
+
+    @property
+    def ready(self) -> bool:
+        return self._ready
+
+    def _validate_configuration(self) -> bool:
+        api_key = os.getenv("TRACELOOP_API_KEY", "").strip()
+        if not api_key:
+            logger.warning("TRACELOOP_API_KEY not set or empty.")
+            return False
+
+        base_url = os.getenv("TRACELOOP_BASE_URL", "https://api.traceloop.com")
+        parsed = urlparse(base_url)
+        if not parsed.netloc:
+            logger.error(f"Invalid TRACELOOP_BASE_URL: {base_url}")
+            return False
+
+        return True
+
+    def _convert_to_traceloop_type(self, value):
+        """Recursively converts a value to a Traceloop compatible type."""
+        from langchain.schema import BaseMessage, Document, HumanMessage, SystemMessage
+
+        from langflow.schema.message import Message
+
+        try:
+            if isinstance(value, dict):
+                value = {key: self._convert_to_traceloop_type(val) for key, val in value.items()}
+
+            elif isinstance(value, list):
+                value = [self._convert_to_traceloop_type(v) for v in value]
+
+            elif isinstance(value, Message):
+                value = value.text
+
+            elif isinstance(value, (BaseMessage | HumanMessage | SystemMessage)):
+                value = str(value.content) if value.content is not None else ""
+
+            elif isinstance(value, Document):
+                value = value.page_content
+
+            elif isinstance(value, (types.GeneratorType | types.NoneType)):
+                value = str(value)
+
+            elif isinstance(value, float) and not math.isfinite(value):
+                value = "NaN"
+
+        except (TypeError, ValueError) as e:
+            logger.warning(f"Failed to convert value {value!r} to traceloop type: {e}")
+            return str(value)
+        else:
+            return value
+
+    def _convert_to_traceloop_dict(self, io_dict: Any) -> dict[str, Any]:
+        """Ensure values are OTel-compatible. Dicts stay dicts, lists get JSON-serialized."""
+        if isinstance(io_dict, dict):
+            return {str(k): self._convert_to_traceloop_type(v) for k, v in io_dict.items()}
+        if isinstance(io_dict, list):
+            return {"list": json.dumps([self._convert_to_traceloop_type(v) for v in io_dict], default=str)}
+
+        return {"value": self._convert_to_traceloop_type(io_dict)}
+
+    @override
+    def add_trace(
+        self,
+        trace_id: str,
+        trace_name: str,
+        trace_type: str,
+        inputs: dict[str, Any],
+        metadata: dict[str, Any] | None = None,
+        vertex: Vertex | None = None,
+    ) -> None:
+        if not self.ready:
+            return
+
+        span_context = self.propagator.extract(carrier=self.carrier)
+        child_span = self._tracer.start_span(
+            name=trace_name,
+            context=span_context,
+            start_time=self._get_current_timestamp(),
+        )
+
+        attributes = {
+            "trace_id": trace_id,
+            "trace_name": trace_name,
+            "trace_type": trace_type,
+            "inputs": json.dumps(self._convert_to_traceloop_dict(inputs), default=str),
+            **self._convert_to_traceloop_dict(metadata or {}),
+        }
+        if vertex and vertex.id is not None:
+            attributes["vertex_id"] = vertex.id
+
+        child_span.set_attributes(attributes)
+
+        self.child_spans[trace_id] = child_span
+
+    @override
+    def end_trace(
+        self,
+        trace_id: str,
+        trace_name: str,
+        outputs: dict[str, Any] | None = None,
+        error: Exception | None = None,
+        logs: Sequence[Log | dict] = (),
+    ) -> None:
+        if not self._ready or trace_id not in self.child_spans:
+            return
+
+        child_span = self.child_spans.pop(trace_id)
+
+        if outputs:
+            child_span.set_attribute("outputs", json.dumps(self._convert_to_traceloop_dict(outputs), default=str))
+        if logs:
+            child_span.set_attribute("logs", json.dumps(self._convert_to_traceloop_dict(list(logs)), default=str))
+        if error:
+            child_span.record_exception(error)
+
+        child_span.end()
+
+    @override
+    def end(
+        self,
+        inputs: dict[str, Any],
+        outputs: dict[str, Any],
+        error: Exception | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        if not self.ready:
+            return
+
+        safe_outputs = self._convert_to_traceloop_dict(outputs)
+        safe_metadata = self._convert_to_traceloop_dict(metadata or {})
+
+        self.root_span.set_attributes(
+            {
+                "workflow_name": self.trace_name,
+                "workflow_id": str(self.trace_id),
+                "outputs": json.dumps(safe_outputs, default=str),
+                **safe_metadata,
+            }
+        )
+        if error:
+            self.root_span.record_exception(error)
+
+        self.root_span.end()
+
+    @staticmethod
+    def _get_current_timestamp() -> int:
+        return int(datetime.now(timezone.utc).timestamp() * 1_000_000_000)
+
+    @override
+    def get_langchain_callback(self) -> BaseCallbackHandler | None:
+        return None
+
+    def close(self):
+        try:
+            provider = trace.get_tracer_provider()
+            if hasattr(provider, "force_flush"):
+                provider.force_flush(timeout_millis=3000)
+        except (ValueError, RuntimeError, OSError) as e:
+            logger.warning(f"Error flushing spans: {e}")
+
+    def __del__(self):
+        self.close()

langflow/services/utils.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import asyncio
 from typing import TYPE_CHECKING
 
-from loguru import logger
 from sqlalchemy import delete
 from sqlalchemy import exc as sqlalchemy_exc
 from sqlmodel import col, select
 
+from langflow.logging.logger import logger
 from langflow.services.auth.utils import create_super_user, verify_password
 from langflow.services.cache.base import ExternalAsyncBaseCacheService
 from langflow.services.cache.factory import CacheServiceFactory
@@ -45,7 +45,7 @@ async def get_or_create_super_user(session: AsyncSession, username, password, is
             # This means that the user has already created
             # a superuser and changed the password in the UI
             # so we don't need to do anything.
-            logger.debug(
+            await logger.adebug(
                 "Superuser exists but password is incorrect. "
                 "This means that the user has changed the "
                 "base superuser credentials."
@@ -70,7 +70,7 @@ async def get_or_create_super_user(session: AsyncSession, username, password, is
 
 async def setup_superuser(settings_service: SettingsService, session: AsyncSession) -> None:
     if settings_service.auth_settings.AUTO_LOGIN:
-        logger.debug("AUTO_LOGIN is set to True. Creating default superuser.")
+        await logger.adebug("AUTO_LOGIN is set to True. Creating default superuser.")
         username = DEFAULT_SUPERUSER
         password = DEFAULT_SUPERUSER_PASSWORD
     else:
@@ -90,7 +90,7 @@ async def setup_superuser(settings_service: SettingsService, session: AsyncSessi
             session=session, username=username, password=password, is_default=is_default
         )
         if user is not None:
-            logger.debug("Superuser created successfully.")
+            await logger.adebug("Superuser created successfully.")
     except Exception as exc:
         logger.exception(exc)
         msg = "Could not create superuser. Please create a superuser manually."
@@ -106,7 +106,7 @@ async def teardown_superuser(settings_service, session: AsyncSession) -> None:
 
     if not settings_service.auth_settings.AUTO_LOGIN:
         try:
-            logger.debug("AUTO_LOGIN is set to False. Removing default superuser if exists.")
+            await logger.adebug("AUTO_LOGIN is set to False. Removing default superuser if exists.")
             username = DEFAULT_SUPERUSER
             from langflow.services.database.models.user.model import User
 
@@ -118,7 +118,7 @@ async def teardown_superuser(settings_service, session: AsyncSession) -> None:
             if user and user.is_superuser is True and not user.last_login_at:
                 await session.delete(user)
                 await session.commit()
-                logger.debug("Default superuser removed successfully.")
+                await logger.adebug("Default superuser removed successfully.")
 
         except Exception as exc:
             logger.exception(exc)
@@ -238,6 +238,6 @@ async def initialize_services(*, fix_migration: bool = False) -> None:
     try:
         await get_db_service().assign_orphaned_flows_to_superuser()
     except sqlalchemy_exc.IntegrityError as exc:
-        logger.warning(f"Error assigning orphaned flows to the superuser: {exc!s}")
+        await logger.awarning(f"Error assigning orphaned flows to the superuser: {exc!s}")
     await clean_transactions(settings_service, session)
     await clean_vertex_builds(settings_service, session)

langflow/services/variable/kubernetes.py

@@ -4,9 +4,9 @@ import asyncio
 import os
 from typing import TYPE_CHECKING
 
-from loguru import logger
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.services.auth import utils as auth_utils
 from langflow.services.base import Service
 from langflow.services.database.models.variable.model import Variable, VariableCreate, VariableRead
@@ -33,12 +33,12 @@ class KubernetesSecretService(VariableService, Service):
     async def initialize_user_variables(self, user_id: UUID | str, session: AsyncSession) -> None:
         # Check for environment variables that should be stored in the database
         should_or_should_not = "Should" if self.settings_service.settings.store_environment_variables else "Should not"
-        logger.info(f"{should_or_should_not} store environment variables in the kubernetes.")
+        await logger.ainfo(f"{should_or_should_not} store environment variables in the kubernetes.")
         if self.settings_service.settings.store_environment_variables:
             variables = {}
             for var in self.settings_service.settings.variables_to_get_from_environment:
                 if var in os.environ:
-                    logger.debug(f"Creating {var} variable from environment.")
+                    await logger.adebug(f"Creating {var} variable from environment.")
                     value = os.environ[var]
                     if isinstance(value, str):
                         value = value.strip()

langflow/services/variable/kubernetes_secrets.py

@@ -4,7 +4,8 @@ from uuid import UUID
 
 from kubernetes import client, config
 from kubernetes.client.rest import ApiException
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 
 class KubernetesSecretManager: