feat: add ops trace (#5483)

Co-authored-by: takatost <takatost@gmail.com>

api/services/app_generate_service.py

@@ -18,7 +18,8 @@ class AppGenerateService:
                  user: Union[Account, EndUser],
                  args: Any,
                  invoke_from: InvokeFrom,
-                 streaming: bool = True) -> Union[dict, Generator[dict, None, None]]:
+                 streaming: bool = True,
+                 ) -> Union[dict, Generator[dict, None, None]]:
         """
         App Content Generate
         :param app_model: app model

api/services/conversation_service.py

@@ -96,7 +96,9 @@ class ConversationService:
 
         # generate conversation name
         try:
-            name = LLMGenerator.generate_conversation_name(app_model.tenant_id, message.query)
+            name = LLMGenerator.generate_conversation_name(
+                app_model.tenant_id, message.query, conversation.id, app_model.id
+            )
             conversation.name = name
         except:
             pass

api/services/message_service.py

@@ -7,6 +7,8 @@ from core.llm_generator.llm_generator import LLMGenerator
 from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelManager
 from core.model_runtime.entities.model_entities import ModelType
+from core.ops.ops_trace_manager import TraceQueueManager, TraceTask, TraceTaskName
+from core.ops.utils import measure_time
 from extensions.ext_database import db
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from models.account import Account
@@ -262,9 +264,21 @@ class MessageService:
             message_limit=3,
         )
 
-        questions = LLMGenerator.generate_suggested_questions_after_answer(
-            tenant_id=app_model.tenant_id,
-            histories=histories
+        with measure_time() as timer:
+            questions = LLMGenerator.generate_suggested_questions_after_answer(
+                tenant_id=app_model.tenant_id,
+                histories=histories
+            )
+
+        # get tracing instance
+        trace_manager = TraceQueueManager(app_id=app_model.id)
+        trace_manager.add_trace_task(
+            TraceTask(
+                TraceTaskName.SUGGESTED_QUESTION_TRACE,
+                message_id=message_id,
+                suggested_question=questions,
+                timer=timer
+            )
         )
 
         return questions

api/services/ops_service.py

@@ -0,0 +1,130 @@
+from core.ops.ops_trace_manager import OpsTraceManager, provider_config_map
+from extensions.ext_database import db
+from models.model import App, TraceAppConfig
+
+
+class OpsService:
+    @classmethod
+    def get_tracing_app_config(cls, app_id: str, tracing_provider: str):
+        """
+        Get tracing app config
+        :param app_id: app id
+        :param tracing_provider: tracing provider
+        :return:
+        """
+        trace_config_data: TraceAppConfig = db.session.query(TraceAppConfig).filter(
+            TraceAppConfig.app_id == app_id, TraceAppConfig.tracing_provider == tracing_provider
+        ).first()
+
+        if not trace_config_data:
+            return None
+
+        # decrypt_token and obfuscated_token
+        tenant_id = db.session.query(App).filter(App.id == app_id).first().tenant_id
+        decrypt_tracing_config = OpsTraceManager.decrypt_tracing_config(tenant_id, tracing_provider, trace_config_data.tracing_config)
+        decrypt_tracing_config = OpsTraceManager.obfuscated_decrypt_token(tracing_provider, decrypt_tracing_config)
+
+        trace_config_data.tracing_config = decrypt_tracing_config
+
+        return trace_config_data.to_dict()
+
+    @classmethod
+    def create_tracing_app_config(cls, app_id: str, tracing_provider: str, tracing_config: dict):
+        """
+        Create tracing app config
+        :param app_id: app id
+        :param tracing_provider: tracing provider
+        :param tracing_config: tracing config
+        :return:
+        """
+        if tracing_provider not in provider_config_map.keys() and tracing_provider != None:
+            return {"error": f"Invalid tracing provider: {tracing_provider}"}
+
+        config_class, other_keys = provider_config_map[tracing_provider]['config_class'], \
+            provider_config_map[tracing_provider]['other_keys']
+        default_config_instance = config_class(**tracing_config)
+        for key in other_keys:
+            if key in tracing_config and tracing_config[key] == "":
+                tracing_config[key] = getattr(default_config_instance, key, None)
+
+        # api check
+        if not OpsTraceManager.check_trace_config_is_effective(tracing_config, tracing_provider):
+            return {"error": "Invalid Credentials"}
+
+        # check if trace config already exists
+        trace_config_data: TraceAppConfig = db.session.query(TraceAppConfig).filter(
+            TraceAppConfig.app_id == app_id, TraceAppConfig.tracing_provider == tracing_provider
+        ).first()
+
+        if trace_config_data:
+            return None
+
+        # get tenant id
+        tenant_id = db.session.query(App).filter(App.id == app_id).first().tenant_id
+        tracing_config = OpsTraceManager.encrypt_tracing_config(tenant_id, tracing_provider, tracing_config)
+        trace_config_data = TraceAppConfig(
+            app_id=app_id,
+            tracing_provider=tracing_provider,
+            tracing_config=tracing_config,
+        )
+        db.session.add(trace_config_data)
+        db.session.commit()
+
+        return {"result": "success"}
+
+    @classmethod
+    def update_tracing_app_config(cls, app_id: str, tracing_provider: str, tracing_config: dict):
+        """
+        Update tracing app config
+        :param app_id: app id
+        :param tracing_provider: tracing provider
+        :param tracing_config: tracing config
+        :return:
+        """
+        if tracing_provider not in provider_config_map.keys():
+            raise ValueError(f"Invalid tracing provider: {tracing_provider}")
+
+        # check if trace config already exists
+        current_trace_config = db.session.query(TraceAppConfig).filter(
+            TraceAppConfig.app_id == app_id, TraceAppConfig.tracing_provider == tracing_provider
+        ).first()
+
+        if not current_trace_config:
+            return None
+
+        # get tenant id
+        tenant_id = db.session.query(App).filter(App.id == app_id).first().tenant_id
+        tracing_config = OpsTraceManager.encrypt_tracing_config(
+            tenant_id, tracing_provider, tracing_config, current_trace_config.tracing_config
+        )
+
+        # api check
+        # decrypt_token
+        decrypt_tracing_config = OpsTraceManager.decrypt_tracing_config(tenant_id, tracing_provider, tracing_config)
+        if not OpsTraceManager.check_trace_config_is_effective(decrypt_tracing_config, tracing_provider):
+            raise ValueError("Invalid Credentials")
+
+        current_trace_config.tracing_config = tracing_config
+        db.session.commit()
+
+        return current_trace_config.to_dict()
+
+    @classmethod
+    def delete_tracing_app_config(cls, app_id: str, tracing_provider: str):
+        """
+        Delete tracing app config
+        :param app_id: app id
+        :param tracing_provider: tracing provider
+        :return:
+        """
+        trace_config = db.session.query(TraceAppConfig).filter(
+            TraceAppConfig.app_id == app_id, TraceAppConfig.tracing_provider == tracing_provider
+        ).first()
+
+        if not trace_config:
+            return None
+
+        db.session.delete(trace_config)
+        db.session.commit()
+
+        return True