Skip to content

armgit / dify

Public Imported from GitHub
0

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.

fix: handle missing optional tracing dependencies (#42724)

Xin Zhange11a20ace4ac
diff --git a/api/controllers/console/app/app.py b/api/controllers/console/app/app.py
index 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 TracingProviderUnavailableError
from controllers.console.app.wraps import get_app_model, with_session
from controllers.console.workspace.models import LoadBalancingPayload
from 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 TraceProviderNotInstalledError
from core.ops.ops_trace_manager import OpsTraceManager
from core.rag.entities import PreProcessingRule, Rule, Segmentation
from 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 error
return SimpleResultResponse(result="success").model_dump(mode="json")
diff --git a/api/controllers/console/app/error.py b/api/controllers/console/app/error.py
index 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.py
index 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 error
except AppTracingConfigInvalidProviderError as error:
raise UnsupportedTracingProviderError() from error
+ except AppTracingConfigProviderUnavailableError as error:
+ raise TracingProviderUnavailableError() from error
except AppTracingConfigProcessingError as error:
raise TracingConfigProcessingError() from error
except ValueError as error:
@@ -177,6 +181,8 @@ class TraceAppConfigApi(Resource):
raise TracingConfigAlreadyExistsError() from error
except AppTracingConfigInvalidProviderError as error:
raise UnsupportedTracingProviderError() from error
+ except AppTracingConfigProviderUnavailableError as error:
+ raise TracingProviderUnavailableError() from error
except AppTracingConfigInvalidConfigurationError as error:
raise InvalidTracingConfigError() from error
except AppTracingConfigVerificationFailedError as error:
@@ -226,6 +232,8 @@ class TraceAppConfigApi(Resource):
raise TracingConfigNotFoundError() from error
except AppTracingConfigInvalidProviderError as error:
raise UnsupportedTracingProviderError() from error
+ except AppTracingConfigProviderUnavailableError as error:
+ raise TracingProviderUnavailableError() from error
except AppTracingConfigInvalidConfigurationError as error:
raise InvalidTracingConfigError() from error
except AppTracingConfigVerificationFailedError as error:
diff --git a/api/core/ops/exceptions.py b/api/core/ops/exceptions.py
index 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.py
index 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.util
import json
import logging
import os
@@ -39,6 +40,7 @@ from core.ops.entities.trace_entity import (
WorkflowNodeTraceInfo,
WorkflowTraceInfo,
)
+from core.ops.exceptions import TraceProviderNotInstalledError
from core.ops.unified_trace.registry import UnifiedProviderConfigEntry, unified_provider_config_map
from core.ops.utils import JSON_DICT_ADAPTER, get_message_data
from extensions.ext_database import db
@@ -335,8 +337,10 @@ class OpsTraceProviderConfigMap(collections.UserDict[str, TracingProviderConfigE
case _:
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 error
provider_config_map = OpsTraceProviderConfigMap()
@@ -589,10 +593,10 @@ class OpsTraceManager:
"""
# auth check
if 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.py
index 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, override
from 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 TraceProviderNotInstalledError
from core.ops.ops_trace_manager import OpsTraceManager, TracingProviderConfigEntry, provider_config_map
from services.app_tracing_config_service import (
AppTracingConfigInvalidConfigurationError,
AppTracingConfigInvalidProviderError,
AppTracingConfigProcessingError,
+ AppTracingConfigProviderUnavailableError,
AppTracingConfigVerificationFailedError,
TracingConfigProviderGateway,
)
@@ -33,7 +35,8 @@ _PROJECT_URL_FALLBACKS = {
class OpsTraceManagerGateway(TracingConfigProviderGateway):
@override
def validate_provider(self, tracing_provider: str) -> None:
- self._provider_config(tracing_provider)
+ if tracing_provider not in TracingProviderEnum:
+ raise AppTracingConfigInvalidProviderError(tracing_provider)
@override
def 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 error
except 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
@staticmethod
def _normalize_config(
diff --git a/api/services/app_tracing_config_service.py b/api/services/app_tracing_config_service.py
index 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.py
index 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 inspect
from collections.abc import Callable
from datetime import datetime
from types import SimpleNamespace
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
from uuid import UUID
import pytest
@@ -13,6 +13,7 @@ from werkzeug.exceptions import Forbidden
from controllers.common.rbac import PlainApp
from controllers.console import flask_admission
+from controllers.console.app import app as app_module
from controllers.console.app import ops_trace as ops_trace_module
from 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 TraceProviderNotInstalledError
from libs.exception import BaseHTTPException
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import Account, AccountStatus, TenantAccountRole
+from services.app_tracing_config_gateway import OpsTraceManagerGateway
from 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.py
index 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 builtins
import json
import queue
+import sys
from collections.abc import Iterator
from datetime import datetime, timedelta
from decimal import Decimal
from types import SimpleNamespace
-from unittest.mock import PropertyMock, patch
+from unittest.mock import MagicMock, PropertyMock, patch
from uuid import UUID
import pytest
@@ -18,6 +20,7 @@ from sqlalchemy.orm import Session, scoped_session, sessionmaker
import core.ops.ops_trace_manager as module
from core.moderation.base import ModerationAction, ModerationInputsResult
+from core.ops.exceptions import TraceProviderNotInstalledError
from core.ops.ops_trace_manager import OpsTraceManager, TraceQueueManager, TraceTask, TraceTaskName
from core.rag.models.document import Document as RetrievalDocument
from 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: None
OpsTraceManager.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.py
index 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, patch
import pytest
from 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 TraceProviderNotInstalledError
from core.ops.ops_trace_manager import TracingProviderConfigEntry
from services import app_tracing_config_gateway as gateway_module
from 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.MonkeyPa
OpsTraceManagerGateway().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,