Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
fix: handle missing optional tracing dependencies (#42724)
Xin Zhange11a20ace4ac
diff --git a/api/controllers/console/app/app.py b/api/controllers/console/app/app.pyindex 51332a9b5ae..9bf89145992 100644--- a/api/controllers/console/app/app.py+++ b/api/controllers/console/app/app.py@@ -23,6 +23,7 @@ from controllers.common.schema import (register_schema_models,)from controllers.console import console_ns+from controllers.console.app.error import TracingProviderUnavailableErrorfrom controllers.console.app.wraps import get_app_model, with_sessionfrom controllers.console.workspace.models import LoadBalancingPayloadfrom controllers.console.wraps import (@@ -40,6 +41,7 @@ from controllers.console.wraps import (with_current_user_id,)from core.file.remote_file_metadata import FileInfo+from core.ops.exceptions import TraceProviderNotInstalledErrorfrom core.ops.ops_trace_manager import OpsTraceManagerfrom core.rag.entities import PreProcessingRule, Rule, Segmentationfrom core.rag.retrieval.retrieval_methods import RetrievalMethod@@ -1316,10 +1318,13 @@ class AppTraceApi(Resource):def post(self, req_data: AppTracePayload, app_model: App):# add app trace- OpsTraceManager.update_app_tracing_config(- app_id=app_model.id,- enabled=req_data.enabled,- tracing_provider=req_data.tracing_provider,- )+ try:+ OpsTraceManager.update_app_tracing_config(+ app_id=app_model.id,+ enabled=req_data.enabled,+ tracing_provider=req_data.tracing_provider,+ )+ except TraceProviderNotInstalledError as error:+ raise TracingProviderUnavailableError() from errorreturn SimpleResultResponse(result="success").model_dump(mode="json")diff --git a/api/controllers/console/app/error.py b/api/controllers/console/app/error.pyindex dd9725291ee..97a0cbedbef 100644--- a/api/controllers/console/app/error.py+++ b/api/controllers/console/app/error.py@@ -125,6 +125,12 @@ class UnsupportedTracingProviderError(BaseHTTPException):code = 400+class TracingProviderUnavailableError(BaseHTTPException):+ error_code = "tracing_provider_unavailable"+ description = "The tracing provider is not available in this deployment."+ code = 400++class InvalidTracingConfigError(BaseHTTPException):error_code = "invalid_tracing_config"description = "The tracing configuration is invalid."diff --git a/api/controllers/console/app/ops_trace.py b/api/controllers/console/app/ops_trace.pyindex 4dbe8bc8d07..d81b0a1abbe 100644--- a/api/controllers/console/app/ops_trace.py+++ b/api/controllers/console/app/ops_trace.py@@ -14,6 +14,7 @@ from controllers.console.app.error import (TracingConfigNotFoundError,TracingConfigProcessingError,TracingConfigVerificationFailedError,+ TracingProviderUnavailableError,UnsupportedTracingProviderError,)from controllers.console.flask_admission import console_account_admission@@ -33,6 +34,7 @@ from services.app_tracing_config_service import (AppTracingConfigInvalidProviderError,AppTracingConfigNotFoundError,AppTracingConfigProcessingError,+ AppTracingConfigProviderUnavailableError,AppTracingConfigRecord,AppTracingConfigVerificationFailedError,)@@ -125,6 +127,8 @@ class TraceAppConfigApi(Resource):raise AppNotFoundError() from errorexcept AppTracingConfigInvalidProviderError as error:raise UnsupportedTracingProviderError() from error+ except AppTracingConfigProviderUnavailableError as error:+ raise TracingProviderUnavailableError() from errorexcept AppTracingConfigProcessingError as error:raise TracingConfigProcessingError() from errorexcept ValueError as error:@@ -177,6 +181,8 @@ class TraceAppConfigApi(Resource):raise TracingConfigAlreadyExistsError() from errorexcept AppTracingConfigInvalidProviderError as error:raise UnsupportedTracingProviderError() from error+ except AppTracingConfigProviderUnavailableError as error:+ raise TracingProviderUnavailableError() from errorexcept AppTracingConfigInvalidConfigurationError as error:raise InvalidTracingConfigError() from errorexcept AppTracingConfigVerificationFailedError as error:@@ -226,6 +232,8 @@ class TraceAppConfigApi(Resource):raise TracingConfigNotFoundError() from errorexcept AppTracingConfigInvalidProviderError as error:raise UnsupportedTracingProviderError() from error+ except AppTracingConfigProviderUnavailableError as error:+ raise TracingProviderUnavailableError() from errorexcept AppTracingConfigInvalidConfigurationError as error:raise InvalidTracingConfigError() from errorexcept AppTracingConfigVerificationFailedError as error:diff --git a/api/core/ops/exceptions.py b/api/core/ops/exceptions.pyindex 5e695dcdbd8..35ceff6124d 100644--- a/api/core/ops/exceptions.py+++ b/api/core/ops/exceptions.py@@ -5,6 +5,11 @@ generic Celery tasks should not import provider-specific exception classes."""+class TraceProviderNotInstalledError(ImportError):+ def __init__(self, tracing_provider: str, module_name: str) -> None:+ super().__init__(f"Tracing provider {tracing_provider} requires the missing module {module_name}.")++class RetryableTraceDispatchError(RuntimeError):"""Base class for transient trace dispatch failures that Celery may retry."""diff --git a/api/core/ops/ops_trace_manager.py b/api/core/ops/ops_trace_manager.pyindex 8011811295b..336a3427b28 100644--- a/api/core/ops/ops_trace_manager.py+++ b/api/core/ops/ops_trace_manager.py@@ -1,4 +1,5 @@import collections+import importlib.utilimport jsonimport loggingimport os@@ -39,6 +40,7 @@ from core.ops.entities.trace_entity import (WorkflowNodeTraceInfo,WorkflowTraceInfo,)+from core.ops.exceptions import TraceProviderNotInstalledErrorfrom core.ops.unified_trace.registry import UnifiedProviderConfigEntry, unified_provider_config_mapfrom core.ops.utils import JSON_DICT_ADAPTER, get_message_datafrom extensions.ext_database import db@@ -335,8 +337,10 @@ class OpsTraceProviderConfigMap(collections.UserDict[str, TracingProviderConfigEcase _:raise KeyError(f"Unsupported tracing provider: {key}")- except ImportError:- raise ImportError(f"Provider {key} is not installed.")+ except ModuleNotFoundError as error:+ if error.name is None or importlib.util.find_spec(error.name.partition(".")[0]) is not None:+ raise+ raise TraceProviderNotInstalledError(key, error.name) from errorprovider_config_map = OpsTraceProviderConfigMap()@@ -589,10 +593,10 @@ class OpsTraceManager:"""# auth checkif tracing_provider is not None:- try:- provider_config_map[tracing_provider]- except KeyError:+ if tracing_provider not in TracingProviderEnum:raise ValueError(f"Invalid tracing provider: {tracing_provider}")+ if enabled:+ provider_config_map[tracing_provider]app_config: App | None = db.session.get(App, app_id)if not app_config:diff --git a/api/services/app_tracing_config_gateway.py b/api/services/app_tracing_config_gateway.pyindex 637260df48d..348cbd2ff5b 100644--- a/api/services/app_tracing_config_gateway.py+++ b/api/services/app_tracing_config_gateway.py@@ -5,12 +5,14 @@ from typing import Any, overridefrom pydantic import ValidationError-from core.ops.entities.config_entity import BaseTracingConfig+from core.ops.entities.config_entity import BaseTracingConfig, TracingProviderEnum+from core.ops.exceptions import TraceProviderNotInstalledErrorfrom core.ops.ops_trace_manager import OpsTraceManager, TracingProviderConfigEntry, provider_config_mapfrom services.app_tracing_config_service import (AppTracingConfigInvalidConfigurationError,AppTracingConfigInvalidProviderError,AppTracingConfigProcessingError,+ AppTracingConfigProviderUnavailableError,AppTracingConfigVerificationFailedError,TracingConfigProviderGateway,)@@ -33,7 +35,8 @@ _PROJECT_URL_FALLBACKS = {class OpsTraceManagerGateway(TracingConfigProviderGateway):@overridedef validate_provider(self, tracing_provider: str) -> None:- self._provider_config(tracing_provider)+ if tracing_provider not in TracingProviderEnum:+ raise AppTracingConfigInvalidProviderError(tracing_provider)@overridedef prepare_new_config(@@ -107,6 +110,8 @@ class OpsTraceManagerGateway(TracingConfigProviderGateway):tracing_config,)presented_config = OpsTraceManager.obfuscated_decrypt_token(tracing_provider, decrypted_config)+ except TraceProviderNotInstalledError as error:+ raise AppTracingConfigProviderUnavailableError from errorexcept Exception as error:raise AppTracingConfigProcessingError from error@@ -133,6 +138,8 @@ class OpsTraceManagerGateway(TracingConfigProviderGateway):return provider_config_map[tracing_provider]except KeyError as error:raise AppTracingConfigInvalidProviderError(tracing_provider) from error+ except TraceProviderNotInstalledError as error:+ raise AppTracingConfigProviderUnavailableError from error@staticmethoddef _normalize_config(diff --git a/api/services/app_tracing_config_service.py b/api/services/app_tracing_config_service.pyindex 10d3eac61a8..6d7867fa86b 100644--- a/api/services/app_tracing_config_service.py+++ b/api/services/app_tracing_config_service.py@@ -107,6 +107,11 @@ class AppTracingConfigInvalidProviderError(AppTracingConfigError):super().__init__(f"Invalid tracing provider: {tracing_provider}")+class AppTracingConfigProviderUnavailableError(AppTracingConfigError):+ def __init__(self) -> None:+ super().__init__("The tracing provider is not available in this deployment.")++class AppTracingConfigInvalidConfigurationError(AppTracingConfigError):"""The submitted provider configuration does not match its schema."""diff --git a/api/tests/unit_tests/controllers/console/app/test_ops_trace_api.py b/api/tests/unit_tests/controllers/console/app/test_ops_trace_api.pyindex 25f94e9aa67..e19d82c9a3b 100644--- a/api/tests/unit_tests/controllers/console/app/test_ops_trace_api.py+++ b/api/tests/unit_tests/controllers/console/app/test_ops_trace_api.py@@ -4,7 +4,7 @@ import inspectfrom collections.abc import Callablefrom datetime import datetimefrom types import SimpleNamespace-from unittest.mock import MagicMock+from unittest.mock import MagicMock, patchfrom uuid import UUIDimport pytest@@ -13,6 +13,7 @@ from werkzeug.exceptions import Forbiddenfrom controllers.common.rbac import PlainAppfrom controllers.console import flask_admission+from controllers.console.app import app as app_modulefrom controllers.console.app import ops_trace as ops_trace_modulefrom controllers.console.app.error import (AppNotFoundError,@@ -21,12 +22,15 @@ from controllers.console.app.error import (TracingConfigNotFoundError,TracingConfigProcessingError,TracingConfigVerificationFailedError,+ TracingProviderUnavailableError,UnsupportedTracingProviderError,)+from core.ops.exceptions import TraceProviderNotInstalledErrorfrom libs.exception import BaseHTTPExceptionfrom libs.login import AccountWithTenantfrom machinery.context import RequestContextfrom models.account import Account, AccountStatus, TenantAccountRole+from services.app_tracing_config_gateway import OpsTraceManagerGatewayfrom services.app_tracing_config_service import (AppTracingConfigAlreadyExistsError,AppTracingConfigAppNotFoundError,@@ -34,7 +38,9 @@ from services.app_tracing_config_service import (AppTracingConfigInvalidProviderError,AppTracingConfigNotFoundError,AppTracingConfigProcessingError,+ AppTracingConfigProviderUnavailableError,AppTracingConfigRecord,+ AppTracingConfigService,AppTracingConfigVerificationFailedError,)from tests.unit_tests.config_override import apply_config_overrides@@ -107,6 +113,52 @@ def tracing_configs(monkeypatch: pytest.MonkeyPatch) -> MagicMock:return service[email protected]("method_name", ["get", "delete"])+def test_trace_config_without_sdk_can_be_read_when_absent_or_deleted(+ app: Flask, monkeypatch: pytest.MonkeyPatch, method_name: str+) -> None:+ configs = MagicMock()+ configs.get.return_value = None+ configs.delete.return_value = True+ service = AppTracingConfigService(configs=configs, provider=OpsTraceManagerGateway())+ monkeypatch.setattr(+ ops_trace_module,+ "application_services",+ lambda: SimpleNamespace(app_tracing_configs=service),+ )++ with patch.object(OpsTraceManagerGateway, "_provider_config") as load_provider, app.test_request_context("/"):+ result = _original(_CONTROLLER_METHODS[method_name])(+ ops_trace_module.TraceAppConfigApi(),+ ops_trace_module.TraceProviderQuery(tracing_provider="weave"),+ _request_context(),+ UUID(APP_ID),+ )++ assert result == ({"has_not_configured": True} if method_name == "get" else ("", 204))+ load_provider.assert_not_called()+ if method_name == "delete":+ configs.delete.assert_called_once_with(workspace_id=WORKSPACE_ID, app_id=APP_ID, tracing_provider="weave")+++def test_enable_tracing_maps_missing_dependency_to_unavailable(app: Flask) -> None:+ missing_dependency = TraceProviderNotInstalledError("weave", "wandb")+ with (+ patch.object(app_module.OpsTraceManager, "update_app_tracing_config", side_effect=missing_dependency),+ app.test_request_context("/"),+ pytest.raises(TracingProviderUnavailableError) as caught,+ ):+ _original(app_module.AppTraceApi.post)(+ app_module.AppTraceApi(),+ app_module.AppTracePayload(enabled=True, tracing_provider="weave"),+ SimpleNamespace(id=APP_ID),+ )++ assert caught.value.code == 400+ assert caught.value.error_code == "tracing_provider_unavailable"+ assert caught.value.__cause__ is missing_dependency++@pytest.mark.parametrize("method", _MUTATION_METHODS)def test_trace_config_mutations_reject_read_only_member_when_rbac_is_disabled(app: Flask,@@ -313,6 +365,30 @@ def test_trace_app_config_maps_missing_app_to_404(@pytest.mark.parametrize(("method_name", "service_error", "expected_http_error", "expected_status", "expected_code"),[+ pytest.param(+ "get",+ AppTracingConfigProviderUnavailableError(),+ TracingProviderUnavailableError,+ 400,+ "tracing_provider_unavailable",+ id="get-unavailable-provider",+ ),+ pytest.param(+ "post",+ AppTracingConfigProviderUnavailableError(),+ TracingProviderUnavailableError,+ 400,+ "tracing_provider_unavailable",+ id="post-unavailable-provider",+ ),+ pytest.param(+ "patch",+ AppTracingConfigProviderUnavailableError(),+ TracingProviderUnavailableError,+ 400,+ "tracing_provider_unavailable",+ id="patch-unavailable-provider",+ ),pytest.param("post",AppTracingConfigAlreadyExistsError(),diff --git a/api/tests/unit_tests/core/ops/test_ops_trace_manager.py b/api/tests/unit_tests/core/ops/test_ops_trace_manager.pyindex fdac4c243d0..5d0d0847578 100644--- a/api/tests/unit_tests/core/ops/test_ops_trace_manager.py+++ b/api/tests/unit_tests/core/ops/test_ops_trace_manager.py@@ -2,13 +2,15 @@from __future__ import annotations+import builtinsimport jsonimport queue+import sysfrom collections.abc import Iteratorfrom datetime import datetime, timedeltafrom decimal import Decimalfrom types import SimpleNamespace-from unittest.mock import PropertyMock, patch+from unittest.mock import MagicMock, PropertyMock, patchfrom uuid import UUIDimport pytest@@ -18,6 +20,7 @@ from sqlalchemy.orm import Session, scoped_session, sessionmakerimport core.ops.ops_trace_manager as modulefrom core.moderation.base import ModerationAction, ModerationInputsResult+from core.ops.exceptions import TraceProviderNotInstalledErrorfrom core.ops.ops_trace_manager import OpsTraceManager, TraceQueueManager, TraceTask, TraceTaskNamefrom core.rag.models.document import Document as RetrievalDocumentfrom graphon.enums import WorkflowExecutionStatus@@ -464,17 +467,20 @@ def test_message_config_lookup_uses_real_conversation_and_model_config(database:assert OpsTraceManager.get_app_config_through_message_id("missing") is None-def test_update_and_get_app_tracing_config_persist_state(trace_environment: None, database: Session) -> None:+def test_update_and_get_app_tracing_config_persist_state(+ trace_environment: None, database: Session, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(module, "provider_config_map", FakeProviderMap({"langfuse": PROVIDER_ENTRY}))app = _app(database)assert OpsTraceManager.get_app_tracing_config(app.id, database) == {"enabled": False,"tracing_provider": None,}- OpsTraceManager.update_app_tracing_config(app.id, True, "dummy")+ OpsTraceManager.update_app_tracing_config(app.id, True, "langfuse")database.expire_all()assert OpsTraceManager.get_app_tracing_config(app.id, database) == {"enabled": True,- "tracing_provider": "dummy",+ "tracing_provider": "langfuse",}with pytest.raises(ValueError, match="Invalid tracing provider"):OpsTraceManager.update_app_tracing_config(app.id, True, "missing")@@ -484,6 +490,74 @@ def test_update_and_get_app_tracing_config_persist_state(trace_environment: NoneOpsTraceManager.get_app_tracing_config("missing", database)[email protected]("module_name", ["dify_trace_weave", "wandb"])+def test_provider_loader_identifies_missing_optional_dependency(+ monkeypatch: pytest.MonkeyPatch, module_name: str+) -> None:+ monkeypatch.delitem(sys.modules, "dify_trace_weave.weave_trace", raising=False)+ monkeypatch.setitem(sys.modules, module_name, None)+ with pytest.raises(TraceProviderNotInstalledError, match=f"weave.*{module_name}") as caught:+ module.OpsTraceProviderConfigMap()["weave"]++ cause = caught.value.__cause__+ assert isinstance(cause, ModuleNotFoundError)+ assert cause.name is not None+ assert cause.name.partition(".")[0] == module_name+++ "failure",+ [+ ImportError("cannot import name 'WeaveDataTrace'"),+ ModuleNotFoundError("SDK import failed without identifying a missing module"),+ ModuleNotFoundError("No module named 'json.missing_module'", name="json.missing_module"),+ ],+)+def test_provider_loader_preserves_import_errors_in_installed_packages(failure: ImportError) -> None:+ original_import = builtins.__import__++ def broken_import(name, *args, **kwargs):+ if name.startswith("dify_trace_weave."):+ raise failure+ return original_import(name, *args, **kwargs)++ with patch("builtins.__import__", side_effect=broken_import), pytest.raises(ImportError) as caught:+ module.OpsTraceProviderConfigMap()["weave"]++ assert caught.value is failure++[email protected]("provider", ["weave", None])+def test_disable_tracing_does_not_load_provider(+ database: Session, monkeypatch: pytest.MonkeyPatch, provider: str | None+) -> None:+ app = _app(database, tracing=json.dumps({"enabled": True, "tracing_provider": "weave"}))+ providers = MagicMock()+ monkeypatch.setattr(module, "provider_config_map", providers)++ OpsTraceManager.update_app_tracing_config(app.id, False, provider)++ database.expire_all()+ assert OpsTraceManager.get_app_tracing_config(app.id, database) == {+ "enabled": False,+ "tracing_provider": provider,+ }+ providers.__getitem__.assert_not_called()+++def test_enable_tracing_requires_provider_dependencies(database: Session, monkeypatch: pytest.MonkeyPatch) -> None:+ app = _app(database)+ providers = MagicMock()+ providers.__getitem__.side_effect = TraceProviderNotInstalledError("weave", "wandb")+ monkeypatch.setattr(module, "provider_config_map", providers)++ with pytest.raises(TraceProviderNotInstalledError):+ OpsTraceManager.update_app_tracing_config(app.id, True, "weave")++ database.expire_all()+ assert app.tracing is None++def test_message_trace_reads_real_conversation_app_and_message_file(trace_environment: None,database: Session,diff --git a/api/tests/unit_tests/services/test_app_tracing_config_gateway.py b/api/tests/unit_tests/services/test_app_tracing_config_gateway.pyindex 7a5d7f9e75e..e5f1e4deffa 100644--- a/api/tests/unit_tests/services/test_app_tracing_config_gateway.py+++ b/api/tests/unit_tests/services/test_app_tracing_config_gateway.py@@ -1,9 +1,11 @@-from unittest.mock import patch+from functools import partial+from unittest.mock import MagicMock, patchimport pytestfrom pydantic import ValidationInfo, field_validator-from core.ops.entities.config_entity import BaseTracingConfig+from core.ops.entities.config_entity import BaseTracingConfig, TracingProviderEnum+from core.ops.exceptions import TraceProviderNotInstalledErrorfrom core.ops.ops_trace_manager import TracingProviderConfigEntryfrom services import app_tracing_config_gateway as gateway_modulefrom services.app_tracing_config_gateway import OpsTraceManagerGateway@@ -11,6 +13,7 @@ from services.app_tracing_config_service import (AppTracingConfigInvalidConfigurationError,AppTracingConfigInvalidProviderError,AppTracingConfigProcessingError,+ AppTracingConfigProviderUnavailableError,AppTracingConfigVerificationFailedError,)@@ -45,6 +48,45 @@ def test_validate_provider_rejects_unknown_provider(monkeypatch: pytest.MonkeyPaOpsTraceManagerGateway().validate_provider("unknown")[email protected]("provider", TracingProviderEnum)+def test_validate_provider_does_not_load_optional_dependencies(provider: TracingProviderEnum) -> None:+ with patch.object(OpsTraceManagerGateway, "_provider_config") as load_provider:+ OpsTraceManagerGateway().validate_provider(provider.value)++ load_provider.assert_not_called()++[email protected]("update", [False, True])+def test_prepare_config_reports_missing_provider_dependencies(monkeypatch: pytest.MonkeyPatch, update: bool) -> None:+ missing_dependency = TraceProviderNotInstalledError("weave", "wandb")+ providers = MagicMock()+ providers.__getitem__.side_effect = missing_dependency+ monkeypatch.setattr(gateway_module, "provider_config_map", providers)+ gateway = OpsTraceManagerGateway()+ prepare = (+ partial(gateway.prepare_updated_config, current_tracing_config={}) if update else gateway.prepare_new_config+ )++ with pytest.raises(AppTracingConfigProviderUnavailableError) as caught:+ prepare(workspace_id="workspace-1", tracing_provider="weave", tracing_config={})++ assert caught.value.__cause__ is missing_dependency+++def test_present_config_reports_missing_provider_dependencies() -> None:+ missing_dependency = TraceProviderNotInstalledError("weave", "wandb")+ with patch.object(gateway_module, "OpsTraceManager") as manager:+ manager.decrypt_tracing_config.side_effect = missing_dependency++ with pytest.raises(AppTracingConfigProviderUnavailableError) as caught:+ OpsTraceManagerGateway().present_config(+ workspace_id="workspace-1", tracing_provider="weave", tracing_config={"api_key": "encrypted"}+ )++ assert caught.value.__cause__ is missing_dependency+ manager.obfuscated_decrypt_token.assert_not_called()++def test_prepare_new_config_applies_defaults_validates_and_encrypts(monkeypatch: pytest.MonkeyPatch) -> None:monkeypatch.setattr(gateway_module,