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
refactor(api): extract app statistic queries from console controllers (#41557)
非法操作b15fb30ff5c4
diff --git a/api/controllers/console/app/statistic.py b/api/controllers/console/app/statistic.pyindex 48635166e3a..2ebf60bdcfe 100644--- a/api/controllers/console/app/statistic.py+++ b/api/controllers/console/app/statistic.py@@ -1,31 +1,22 @@+from datetime import datetimefrom decimal import Decimal-import sqlalchemy as sa-from flask import abortfrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validator+from werkzeug.exceptions import BadRequestfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_modelsfrom controllers.console import console_nsfrom controllers.console.app.wraps import get_app_model-from controllers.console.wraps import (- RBACPermission,- RBACResourceScope,- account_initialization_required,- model_validate,- rbac_permission_required,- setup_required,- with_current_user,-)-from core.app.entities.app_invoke_entities import InvokeFrom-from extensions.ext_database import db+from controllers.console.flask_admission import console_account_admission+from controllers.console.wraps import RBACPermission, RBACResourceScope, model_validate+from extensions.ext_application_services import application_servicesfrom fields.base import ResponseModelfrom libs.datetime_utils import parse_time_range-from libs.helper import convert_datetime_to_date, dump_response-from libs.login import login_required-from models import AppMode-from models.account import Account-from models.model import App+from libs.helper import dump_response+from libs.login import current_account_with_tenant+from machinery.context import RequestContext+from models.model import App, AppModeclass StatisticTimeRangeQuery(BaseModel):@@ -142,6 +133,20 @@ register_response_schema_models()+def _resolve_statistic_time_range(+ req_data: StatisticTimeRangeQuery,+) -> tuple[datetime | None, datetime | None, str]:+ timezone = current_account_with_tenant().account.timezone+ assert timezone is not None++ try:+ start_date, end_date = parse_time_range(req_data.start, req_data.end, timezone)+ except ValueError as error:+ raise BadRequest(str(error)) from error++ return start_date, end_date, timezone++@console_ns.route("/apps/<uuid:app_id>/statistics/daily-messages")class DailyMessageStatistic(Resource):@console_ns.doc("get_daily_message_statistics")@@ -152,52 +157,20 @@ class DailyMessageStatistic(Resource):"Daily message statistics retrieved successfully",console_ns.models[DailyMessageStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- COUNT(*) AS message_count-FROM- messages-WHERE- app_id = :app_id- AND invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append({"date": str(i.date), "message_count": i.message_count})+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_daily_messages(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(DailyMessageStatisticResponse, {"data": response_data})@@ -212,51 +185,20 @@ class DailyConversationStatistic(Resource):"Daily conversation statistics retrieved successfully",console_ns.models[DailyConversationStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- COUNT(DISTINCT conversation_id) AS conversation_count-FROM- messages-WHERE- app_id = :app_id- AND invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append({"date": str(i.date), "conversation_count": i.conversation_count})+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_daily_conversations(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(DailyConversationStatisticResponse, {"data": response_data})@@ -271,52 +213,20 @@ class DailyTerminalsStatistic(Resource):"Daily terminal statistics retrieved successfully",console_ns.models[DailyTerminalStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- COUNT(DISTINCT messages.from_end_user_id) AS terminal_count-FROM- messages-WHERE- app_id = :app_id- AND invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append({"date": str(i.date), "terminal_count": i.terminal_count})+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_daily_terminals(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(DailyTerminalStatisticResponse, {"data": response_data})@@ -331,55 +241,20 @@ class DailyTokenCostStatistic(Resource):"Daily token cost statistics retrieved successfully",console_ns.models[DailyTokenCostStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- (SUM(messages.message_tokens) + SUM(messages.answer_tokens)) AS token_count,- SUM(total_price) AS total_price-FROM- messages-WHERE- app_id = :app_id- AND invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append(- {"date": str(i.date), "token_count": i.token_count, "total_price": i.total_price, "currency": "USD"}- )+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_daily_token_costs(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(DailyTokenCostStatisticResponse, {"data": response_data})@@ -394,71 +269,20 @@ class AverageSessionInteractionStatistic(Resource):"Average session interaction statistics retrieved successfully",console_ns.models[AverageSessionInteractionStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("c.created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- AVG(subquery.message_count) AS interactions-FROM- (- SELECT- m.conversation_id,- COUNT(m.id) AS message_count- FROM- conversations c- JOIN- messages m- ON c.id = m.conversation_id- WHERE- c.app_id = :app_id- AND m.invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND c.created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND c.created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += """- GROUP BY m.conversation_id- ) subquery-LEFT JOIN- conversations c- ON c.id = subquery.conversation_id-GROUP BY- date-ORDER BY- date"""-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append(- {"date": str(i.date), "interactions": float(i.interactions.quantize(Decimal("0.01")))}- )+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_average_session_interactions(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(AverageSessionInteractionStatisticResponse, {"data": response_data})@@ -473,61 +297,20 @@ class UserSatisfactionRateStatistic(Resource):"User satisfaction rate statistics retrieved successfully",console_ns.models[UserSatisfactionRateStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("m.created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- COUNT(m.id) AS message_count,- COUNT(mf.id) AS feedback_count-FROM- messages m-LEFT JOIN- message_feedbacks mf- ON mf.message_id=m.id AND mf.rating='like'-WHERE- m.app_id = :app_id- AND m.invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND m.created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND m.created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append(- {- "date": str(i.date),- "rate": round((i.feedback_count * 1000 / i.message_count) if i.message_count > 0 else 0, 2),- }- )+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_user_satisfaction_rates(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(UserSatisfactionRateStatisticResponse, {"data": response_data})@@ -542,52 +325,20 @@ class AverageResponseTimeStatistic(Resource):"Average response time statistics retrieved successfully",console_ns.models[AverageResponseTimeStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model(mode=AppMode.COMPLETION)@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- AVG(provider_response_latency) AS latency-FROM- messages-WHERE- app_id = :app_id- AND invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append({"date": str(i.date), "latency": round(i.latency * 1000, 4)})+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_average_response_times(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(AverageResponseTimeStatisticResponse, {"data": response_data})@@ -602,54 +353,19 @@ class TokensPerSecondStatistic(Resource):"Tokens per second statistics retrieved successfully",console_ns.models[TokensPerSecondStatisticResponse.__name__],)- @setup_required- @login_required- @account_initialization_required- @with_current_user- @rbac_permission_required(RBACResourceScope.APP, RBACPermission.APP_MONITOR)+ @console_account_admission(+ rbac_resource_scope=RBACResourceScope.APP,+ rbac_permission=RBACPermission.APP_MONITOR,+ )@get_app_model@model_validate(StatisticTimeRangeQuery)- def get(self, req_data: StatisticTimeRangeQuery, account: Account, app_model: App):-- converted_created_at = convert_datetime_to_date("created_at")- sql_query = f"""SELECT- {converted_created_at} AS date,- CASE- WHEN SUM(provider_response_latency) = 0 THEN 0- ELSE (SUM(answer_tokens) / SUM(provider_response_latency))- END as tokens_per_second-FROM- messages-WHERE- app_id = :app_id- AND invoke_from != :invoke_from"""- assert account.timezone is not None- arg_dict: dict[str, object] = {- "tz": account.timezone,- "app_id": app_model.id,- "invoke_from": InvokeFrom.DEBUGGER,- }-- try:- start_datetime_utc, end_datetime_utc = parse_time_range(req_data.start, req_data.end, account.timezone)- except ValueError as e:- abort(400, description=str(e))-- if start_datetime_utc:- sql_query += " AND created_at >= :start"- arg_dict["start"] = start_datetime_utc-- if end_datetime_utc:- sql_query += " AND created_at < :end"- arg_dict["end"] = end_datetime_utc-- sql_query += " GROUP BY date ORDER BY date"-- response_data = []-- with db.engine.begin() as conn:- rs = conn.execute(sa.text(sql_query), arg_dict)- for i in rs:- response_data.append({"date": str(i.date), "tps": round(i.tokens_per_second, 4)})+ def get(self, req_data: StatisticTimeRangeQuery, _request_context: RequestContext, app_model: App):+ start_date, end_date, timezone = _resolve_statistic_time_range(req_data)+ response_data = application_services().app_statistics.get_tokens_per_second(+ app_id=app_model.id,+ start_date=start_date,+ end_date=end_date,+ timezone=timezone,+ )return dump_response(TokensPerSecondStatisticResponse, {"data": response_data})diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex c726edae8f5..0c817586b03 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -40,6 +40,7 @@ from repositories.account_oauth_repository import (from repositories.account_repository import SQLAlchemyAccountRepositoryfrom repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.app_site_command_repository import AppSiteCommandRepository+from repositories.app_statistic_query_repository import AppStatisticQueryRepositoryfrom repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepositoryfrom repositories.data_source_oauth_binding_repository import SQLAlchemyDataSourceOAuthBindingRepositoryfrom repositories.explore_banner_query_repository import ExploreBannerQueryRepository@@ -131,6 +132,7 @@ from services.account_password_service import AccountPasswordServicefrom services.account_profile_service import AccountProfileServicefrom services.app_definition_query_service import AppDefinitionQueryServicefrom services.app_site_service import AppSiteService+from services.app_statistic_query import AppStatisticQueryfrom services.auth.data_source_api_key_auth_gateways import (ProviderApiKeyAuthCredentialValidator,TenantApiKeyAuthCredentialEncryptor,@@ -239,6 +241,7 @@ class ApplicationServices:account_activation: AccountActivationServiceapp_definitions: AppDefinitionQueryServiceapp_sites: AppSiteService+ app_statistics: AppStatisticQuerybilling_portal: BillingPortalServicecompliance_downloads: ComplianceDownloadServicedata_source_api_key_auth: DataSourceApiKeyAuthService@@ -585,6 +588,7 @@ def build_application_services(app_sites=AppSiteService(sites=AppSiteCommandRepository(session_factory=database_client),),+ app_statistics=AppStatisticQueryRepository(session_factory=database_client),billing_portal=BillingPortalService(accounts=accounts,get_subscription=BillingService.get_subscription,diff --git a/api/repositories/app_statistic_query_repository.py b/api/repositories/app_statistic_query_repository.pynew file mode 100644index 00000000000..d20502c4bf2--- /dev/null+++ b/api/repositories/app_statistic_query_repository.py@@ -0,0 +1,401 @@+"""Database read model for app monitoring statistics."""++from datetime import datetime+from decimal import Decimal+from typing import override++import sqlalchemy as sa+from sqlalchemy.engine import RowMapping+from sqlalchemy.orm import Session, sessionmaker++from core.app.entities.app_invoke_entities import InvokeFrom+from libs.helper import convert_datetime_to_date+from services.app_statistic_query import (+ AppStatisticQuery,+ AverageResponseTimeStatisticRecord,+ AverageSessionInteractionStatisticRecord,+ DailyConversationStatisticRecord,+ DailyMessageStatisticRecord,+ DailyTerminalStatisticRecord,+ DailyTokenCostStatisticRecord,+ TokensPerSecondStatisticRecord,+ UserSatisfactionRateStatisticRecord,+)+++def _append_time_range(+ sql_query: str,+ parameters: dict[str, object],+ *,+ column: str,+ start_date: datetime | None,+ end_date: datetime | None,+) -> str:+ if start_date is not None:+ sql_query += f" AND {column} >= :start_date"+ parameters["start_date"] = start_date++ if end_date is not None:+ sql_query += f" AND {column} < :end_date"+ parameters["end_date"] = end_date++ return sql_query+++class AppStatisticQueryRepository(AppStatisticQuery):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ def _execute(self, sql_query: str, parameters: dict[str, object]) -> tuple[RowMapping, ...]:+ with self._session_factory() as session:+ return tuple(session.execute(sa.text(sql_query), parameters).mappings())++ @staticmethod+ def _parameters(+ *,+ app_id: str,+ timezone: str,+ ) -> dict[str, object]:+ return {+ "tz": timezone,+ "app_id": app_id,+ "excluded_invoke_from": InvokeFrom.DEBUGGER,+ }++ @override+ def get_daily_messages(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[DailyMessageStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ COUNT(*) AS message_count+FROM+ messages+WHERE+ app_id = :app_id+ AND invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ DailyMessageStatisticRecord(date=str(row["date"]), message_count=row["message_count"])+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_daily_conversations(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[DailyConversationStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ COUNT(DISTINCT conversation_id) AS conversation_count+FROM+ messages+WHERE+ app_id = :app_id+ AND invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ DailyConversationStatisticRecord(+ date=str(row["date"]),+ conversation_count=row["conversation_count"],+ )+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_daily_terminals(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[DailyTerminalStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ COUNT(DISTINCT messages.from_end_user_id) AS terminal_count+FROM+ messages+WHERE+ app_id = :app_id+ AND invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ DailyTerminalStatisticRecord(date=str(row["date"]), terminal_count=row["terminal_count"])+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_daily_token_costs(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[DailyTokenCostStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ (SUM(messages.message_tokens) + SUM(messages.answer_tokens)) AS token_count,+ SUM(total_price) AS total_price+FROM+ messages+WHERE+ app_id = :app_id+ AND invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ DailyTokenCostStatisticRecord(+ date=str(row["date"]),+ token_count=int(row["token_count"]) if row["token_count"] is not None else None,+ total_price=row["total_price"],+ currency="USD",+ )+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_average_session_interactions(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[AverageSessionInteractionStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("c.created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ AVG(subquery.message_count) AS interactions+FROM+ (+ SELECT+ m.conversation_id,+ COUNT(m.id) AS message_count+ FROM+ conversations c+ JOIN+ messages m+ ON c.id = m.conversation_id+ WHERE+ c.app_id = :app_id+ AND m.invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="c.created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += """+ GROUP BY m.conversation_id+ ) subquery+LEFT JOIN+ conversations c+ ON c.id = subquery.conversation_id+GROUP BY+ date+ORDER BY+ date"""++ return tuple(+ AverageSessionInteractionStatisticRecord(+ date=str(row["date"]),+ interactions=float(row["interactions"].quantize(Decimal("0.01"))),+ )+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_user_satisfaction_rates(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[UserSatisfactionRateStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("m.created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ COUNT(m.id) AS message_count,+ COUNT(mf.id) AS feedback_count+FROM+ messages m+LEFT JOIN+ message_feedbacks mf+ ON mf.message_id=m.id AND mf.rating='like'+WHERE+ m.app_id = :app_id+ AND m.invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="m.created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ UserSatisfactionRateStatisticRecord(+ date=str(row["date"]),+ rate=float(+ round(+ row["feedback_count"] * 1000 / row["message_count"] if row["message_count"] > 0 else 0,+ 2,+ )+ ),+ )+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_average_response_times(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[AverageResponseTimeStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ AVG(provider_response_latency) AS latency+FROM+ messages+WHERE+ app_id = :app_id+ AND invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ AverageResponseTimeStatisticRecord(+ date=str(row["date"]),+ latency=round(row["latency"] * 1000, 4),+ )+ for row in self._execute(sql_query, parameters)+ )++ @override+ def get_tokens_per_second(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> tuple[TokensPerSecondStatisticRecord, ...]:+ converted_created_at = convert_datetime_to_date("created_at")+ sql_query = f"""SELECT+ {converted_created_at} AS date,+ CASE+ WHEN SUM(provider_response_latency) = 0 THEN 0+ ELSE (SUM(answer_tokens) / SUM(provider_response_latency))+ END as tokens_per_second+FROM+ messages+WHERE+ app_id = :app_id+ AND invoke_from != :excluded_invoke_from"""+ parameters = self._parameters(+ app_id=app_id,+ timezone=timezone,+ )+ sql_query = _append_time_range(+ sql_query,+ parameters,+ column="created_at",+ start_date=start_date,+ end_date=end_date,+ )+ sql_query += " GROUP BY date ORDER BY date"++ return tuple(+ TokensPerSecondStatisticRecord(+ date=str(row["date"]),+ tps=round(row["tokens_per_second"], 4),+ )+ for row in self._execute(sql_query, parameters)+ )diff --git a/api/services/app_statistic_query.py b/api/services/app_statistic_query.pynew file mode 100644index 00000000000..3b1913b6bca--- /dev/null+++ b/api/services/app_statistic_query.py@@ -0,0 +1,122 @@+"""Application boundary for app monitoring statistics."""++from collections.abc import Sequence+from datetime import datetime+from decimal import Decimal+from typing import NamedTuple, Protocol+++class DailyMessageStatisticRecord(NamedTuple):+ date: str+ message_count: int+++class DailyConversationStatisticRecord(NamedTuple):+ date: str+ conversation_count: int+++class DailyTerminalStatisticRecord(NamedTuple):+ date: str+ terminal_count: int+++class DailyTokenCostStatisticRecord(NamedTuple):+ date: str+ token_count: int | None+ total_price: Decimal | None+ currency: str | None+++class AverageSessionInteractionStatisticRecord(NamedTuple):+ date: str+ interactions: float+++class UserSatisfactionRateStatisticRecord(NamedTuple):+ date: str+ rate: float+++class AverageResponseTimeStatisticRecord(NamedTuple):+ date: str+ latency: float+++class TokensPerSecondStatisticRecord(NamedTuple):+ date: str+ tps: float+++class AppStatisticQuery(Protocol):+ def get_daily_messages(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[DailyMessageStatisticRecord]: ...++ def get_daily_conversations(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[DailyConversationStatisticRecord]: ...++ def get_daily_terminals(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[DailyTerminalStatisticRecord]: ...++ def get_daily_token_costs(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[DailyTokenCostStatisticRecord]: ...++ def get_average_session_interactions(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[AverageSessionInteractionStatisticRecord]: ...++ def get_user_satisfaction_rates(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[UserSatisfactionRateStatisticRecord]: ...++ def get_average_response_times(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[AverageResponseTimeStatisticRecord]: ...++ def get_tokens_per_second(+ self,+ *,+ app_id: str,+ start_date: datetime | None,+ end_date: datetime | None,+ timezone: str,+ ) -> Sequence[TokensPerSecondStatisticRecord]: ...diff --git a/api/tests/unit_tests/controllers/console/app/test_statistic_api.py b/api/tests/unit_tests/controllers/console/app/test_statistic_api.pyindex 2228069b40c..ed77c3ea5df 100644--- a/api/tests/unit_tests/controllers/console/app/test_statistic_api.py+++ b/api/tests/unit_tests/controllers/console/app/test_statistic_api.py@@ -1,255 +1,198 @@from __future__ import annotations+from collections.abc import Callable+from datetime import UTC, datetimefrom decimal import Decimalfrom inspect import unwrapfrom types import SimpleNamespacefrom typing import Any+from unittest.mock import MagicMockimport pytestfrom flask import Flaskfrom werkzeug.exceptions import BadRequestfrom controllers.console.app import statistic as statistic_module-from models.account import Account+from machinery.context import RequestContextfrom models.model import App---def _account() -> Account:- account = Account(name="Statistics Tester", email="[email protected]", timezone="UTC")- account.id = "account-1"- return account+from services.app_statistic_query import (+ AppStatisticQuery,+ AverageResponseTimeStatisticRecord,+ AverageSessionInteractionStatisticRecord,+ DailyConversationStatisticRecord,+ DailyMessageStatisticRecord,+ DailyTerminalStatisticRecord,+ DailyTokenCostStatisticRecord,+ TokensPerSecondStatisticRecord,+ UserSatisfactionRateStatisticRecord,+)+++def _request_context() -> RequestContext:+ return RequestContext(+ request_id="request-1",+ trace_id="trace-1",+ account_id="account-1",+ active_workspace_id="tenant-1",+ )def _app_model() -> App:return App(id="app-1", tenant_id="tenant-1", name="Statistics App")-class _ConnContext:- def __init__(self, rows):- self._rows = rows-- def __enter__(self):- return self-- def __exit__(self, exc_type, exc, tb):- return False-- def execute(self, _query, _args):- return self._rows---def _install_db(monkeypatch: pytest.MonkeyPatch, rows) -> None:- engine = SimpleNamespace(begin=lambda: _ConnContext(rows))- monkeypatch.setattr(statistic_module, "db", SimpleNamespace(engine=engine))---def _install_common(monkeypatch: pytest.MonkeyPatch) -> None:+def _install_dependencies(+ monkeypatch: pytest.MonkeyPatch,+ statistics: MagicMock,+ *,+ time_range: tuple[datetime | None, datetime | None] = (None, None),+) -> None:monkeypatch.setattr(statistic_module,- "parse_time_range",- lambda *_args, **_kwargs: (None, None),+ "application_services",+ lambda: SimpleNamespace(app_statistics=statistics),)- monkeypatch.setattr(statistic_module, "convert_datetime_to_date", lambda field: field)---def _json_payload(response: Any) -> dict[str, Any]:- return response if isinstance(response, dict) else response.get_json()---def test_daily_message_statistic_returns_rows(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyMessageStatistic()- method = unwrap(api.get)-- rows = [SimpleNamespace(date="2024-01-01", message_count=3)]- _install_common(monkeypatch)- _install_db(monkeypatch, rows)-- with app.test_request_context("/console/api/apps/app-1/statistics/daily-messages", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )-- assert _json_payload(response) == {"data": [{"date": "2024-01-01", "message_count": 3}]}---def test_daily_conversation_statistic_returns_rows(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyConversationStatistic()- method = unwrap(api.get)-- rows = [SimpleNamespace(date="2024-01-02", conversation_count=5)]- _install_common(monkeypatch)- _install_db(monkeypatch, rows)-- with app.test_request_context("/console/api/apps/app-1/statistics/daily-conversations", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )-- assert _json_payload(response) == {"data": [{"date": "2024-01-02", "conversation_count": 5}]}---def test_daily_token_cost_statistic_returns_rows(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyTokenCostStatistic()- method = unwrap(api.get)-- rows = [SimpleNamespace(date="2024-01-03", token_count=10, total_price=0.25, currency="USD")]- _install_common(monkeypatch)- _install_db(monkeypatch, rows)-- with app.test_request_context("/console/api/apps/app-1/statistics/token-costs", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )-- data = _json_payload(response)- assert len(data["data"]) == 1- assert data["data"][0]["date"] == "2024-01-03"- assert data["data"][0]["token_count"] == 10- assert Decimal(data["data"][0]["total_price"]) == Decimal("0.25")---def test_daily_terminals_statistic_returns_rows(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyTerminalsStatistic()- method = unwrap(api.get)-- rows = [SimpleNamespace(date="2024-01-04", terminal_count=7)]- _install_common(monkeypatch)- _install_db(monkeypatch, rows)-- with app.test_request_context("/console/api/apps/app-1/statistics/daily-end-users", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )-- assert _json_payload(response) == {"data": [{"date": "2024-01-04", "terminal_count": 7}]}---def test_average_session_interaction_statistic_requires_chat_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- """Test that AverageSessionInteractionStatistic is limited to chat/agent modes."""- # This just verifies the decorator is applied correctly- # Actual endpoint testing would require complex JOIN mocking- api = statistic_module.AverageSessionInteractionStatistic()- method = unwrap(api.get)- assert callable(method)---def test_daily_message_statistic_with_invalid_time_range(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyMessageStatistic()- method = unwrap(api.get)-- def mock_parse(*args, **kwargs):- raise ValueError("Invalid time range")-- _install_db(monkeypatch, [])- monkeypatch.setattr(statistic_module, "parse_time_range", mock_parse)- monkeypatch.setattr(statistic_module, "convert_datetime_to_date", lambda field: field)-- with app.test_request_context("/console/api/apps/app-1/statistics/daily-messages", method="GET"):- with pytest.raises(BadRequest):- method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )---def test_daily_message_statistic_multiple_rows(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyMessageStatistic()- method = unwrap(api.get)-- rows = [- SimpleNamespace(date="2024-01-01", message_count=10),- SimpleNamespace(date="2024-01-02", message_count=15),- SimpleNamespace(date="2024-01-03", message_count=12),- ]- _install_common(monkeypatch)- _install_db(monkeypatch, rows)-- with app.test_request_context("/console/api/apps/app-1/statistics/daily-messages", method="GET"):+ monkeypatch.setattr(+ statistic_module,+ "current_account_with_tenant",+ lambda: SimpleNamespace(account=SimpleNamespace(timezone="UTC")),+ )+ monkeypatch.setattr(statistic_module, "parse_time_range", lambda *_args, **_kwargs: time_range)+++def _invoke(+ app: Flask,+ resource_type: type,+ *,+ start: str | None = None,+ end: str | None = None,+) -> dict[str, Any]:+ resource = resource_type()+ method = unwrap(resource.get)+ with app.test_request_context("/console/api/apps/app-1/statistics", method="GET"):response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),+ resource,+ statistic_module.StatisticTimeRangeQuery(start=start, end=end),+ _request_context(),app_model=_app_model(),)+ return response if isinstance(response, dict) else response.get_json()- data = _json_payload(response)- assert len(data["data"]) == 3---def test_daily_message_statistic_empty_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyMessageStatistic()- method = unwrap(api.get)- _install_common(monkeypatch)- _install_db(monkeypatch, [])+ ("resource_type", "query_call_getter", "record", "expected"),+ [+ pytest.param(+ statistic_module.DailyMessageStatistic,+ lambda query: query.get_daily_messages,+ DailyMessageStatisticRecord(date="2024-01-01", message_count=3),+ {"date": "2024-01-01", "message_count": 3},+ id="daily-messages",+ ),+ pytest.param(+ statistic_module.DailyConversationStatistic,+ lambda query: query.get_daily_conversations,+ DailyConversationStatisticRecord(date="2024-01-02", conversation_count=5),+ {"date": "2024-01-02", "conversation_count": 5},+ id="daily-conversations",+ ),+ pytest.param(+ statistic_module.DailyTerminalsStatistic,+ lambda query: query.get_daily_terminals,+ DailyTerminalStatisticRecord(date="2024-01-03", terminal_count=7),+ {"date": "2024-01-03", "terminal_count": 7},+ id="daily-terminals",+ ),+ pytest.param(+ statistic_module.DailyTokenCostStatistic,+ lambda query: query.get_daily_token_costs,+ DailyTokenCostStatisticRecord(+ date="2024-01-04",+ token_count=10,+ total_price=Decimal("0.25"),+ currency="USD",+ ),+ {"date": "2024-01-04", "token_count": 10, "total_price": "0.25", "currency": "USD"},+ id="daily-token-costs",+ ),+ pytest.param(+ statistic_module.AverageSessionInteractionStatistic,+ lambda query: query.get_average_session_interactions,+ AverageSessionInteractionStatisticRecord(date="2024-01-05", interactions=2.5),+ {"date": "2024-01-05", "interactions": 2.5},+ id="average-session-interactions",+ ),+ pytest.param(+ statistic_module.UserSatisfactionRateStatistic,+ lambda query: query.get_user_satisfaction_rates,+ UserSatisfactionRateStatisticRecord(date="2024-01-06", rate=100.0),+ {"date": "2024-01-06", "rate": 100.0},+ id="user-satisfaction-rate",+ ),+ pytest.param(+ statistic_module.AverageResponseTimeStatistic,+ lambda query: query.get_average_response_times,+ AverageResponseTimeStatisticRecord(date="2024-01-07", latency=1234.0),+ {"date": "2024-01-07", "latency": 1234.0},+ id="average-response-time",+ ),+ pytest.param(+ statistic_module.TokensPerSecondStatistic,+ lambda query: query.get_tokens_per_second,+ TokensPerSecondStatisticRecord(date="2024-01-08", tps=15.5),+ {"date": "2024-01-08", "tps": 15.5},+ id="tokens-per-second",+ ),+ ],+)+def test_statistic_endpoint_delegates_to_statistic_query(+ app: Flask,+ monkeypatch: pytest.MonkeyPatch,+ resource_type: type,+ query_call_getter: Callable[[MagicMock], MagicMock],+ record: tuple,+ expected: dict[str, Any],+) -> None:+ statistics = MagicMock(spec=AppStatisticQuery)+ query_call = query_call_getter(statistics)+ query_call.return_value = [record]+ _install_dependencies(monkeypatch, statistics)++ assert _invoke(app, resource_type) == {"data": [expected]}+ query_call.assert_called_once_with(+ app_id="app-1",+ start_date=None,+ end_date=None,+ timezone="UTC",+ )- with app.test_request_context("/console/api/apps/app-1/statistics/daily-messages", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )- assert _json_payload(response) == {"data": []}+def test_statistic_endpoint_passes_time_range(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:+ statistics = MagicMock(spec=AppStatisticQuery)+ statistics.get_daily_messages.return_value = []+ start_date = datetime(2024, 1, 1, tzinfo=UTC)+ end_date = datetime(2024, 1, 2, tzinfo=UTC)+ _install_dependencies(monkeypatch, statistics, time_range=(start_date, end_date))+ assert _invoke(app, statistic_module.DailyMessageStatistic, start="start", end="end") == {"data": []}+ statistics.get_daily_messages.assert_called_once_with(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="UTC",+ )-def test_daily_conversation_statistic_with_time_range(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyConversationStatistic()- method = unwrap(api.get)- rows = [SimpleNamespace(date="2024-01-02", conversation_count=5)]- _install_db(monkeypatch, rows)+def test_statistic_endpoint_rejects_invalid_time_range(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:+ statistics = MagicMock(spec=AppStatisticQuery)+ _install_dependencies(monkeypatch, statistics)monkeypatch.setattr(statistic_module,"parse_time_range",- lambda *_args, **_kwargs: ("s", "e"),+ MagicMock(side_effect=ValueError("Invalid time range")),)- monkeypatch.setattr(statistic_module, "convert_datetime_to_date", lambda field: field)- with app.test_request_context("/console/api/apps/app-1/statistics/daily-conversations", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )-- assert _json_payload(response) == {"data": [{"date": "2024-01-02", "conversation_count": 5}]}---def test_daily_token_cost_with_multiple_currencies(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- api = statistic_module.DailyTokenCostStatistic()- method = unwrap(api.get)-- rows = [- SimpleNamespace(date="2024-01-01", token_count=100, total_price=Decimal("0.50"), currency="USD"),- SimpleNamespace(date="2024-01-02", token_count=200, total_price=Decimal("1.00"), currency="USD"),- ]- _install_common(monkeypatch)- _install_db(monkeypatch, rows)-- with app.test_request_context("/console/api/apps/app-1/statistics/token-costs", method="GET"):- response = method(- api,- SimpleNamespace(start=None, end=None),- _account(),- app_model=_app_model(),- )+ with pytest.raises(BadRequest, match="Invalid time range"):+ _invoke(app, statistic_module.DailyMessageStatistic)- data = _json_payload(response)- assert len(data["data"]) == 2+ statistics.get_daily_messages.assert_not_called()diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex 4eb8a0ee564..bf9f4d97559 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -29,6 +29,7 @@ from repositories.account_oauth_repository import ()from repositories.account_repository import SQLAlchemyAccountRepositoryfrom repositories.app_site_command_repository import AppSiteCommandRepository+from repositories.app_statistic_query_repository import AppStatisticQueryRepositoryfrom repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepositoryfrom repositories.workflow_run_archive_repository import WorkflowRunArchiveBundleQueryRepositoryfrom services import account_forgot_password_service, recommended_app_catalog_gateway@@ -263,6 +264,20 @@ def test_build_application_services_wires_app_site_boundary(assert services.app_sites._sites._session_factory is sqlite_session_factory+def test_build_application_services_wires_app_statistic_boundary(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )++ assert isinstance(services.app_statistics, AppStatisticQueryRepository)+ assert services.app_statistics._session_factory is sqlite_session_factory++def test_build_application_services_wires_workflow_run_service(sqlite_session_factory: sessionmaker[Session],) -> None:diff --git a/api/tests/unit_tests/repositories/test_app_statistic_query_repository.py b/api/tests/unit_tests/repositories/test_app_statistic_query_repository.pynew file mode 100644index 00000000000..b8fb51e3dad--- /dev/null+++ b/api/tests/unit_tests/repositories/test_app_statistic_query_repository.py@@ -0,0 +1,155 @@+from datetime import UTC, datetime+from decimal import Decimal+from typing import cast, override++import pytest+from sqlalchemy.engine import RowMapping+from sqlalchemy.orm import Session, sessionmaker++from core.app.entities.app_invoke_entities import InvokeFrom+from repositories import app_statistic_query_repository as repository_module+from repositories.app_statistic_query_repository import AppStatisticQueryRepository+from services.app_statistic_query import (+ AverageResponseTimeStatisticRecord,+ AverageSessionInteractionStatisticRecord,+ DailyConversationStatisticRecord,+ DailyMessageStatisticRecord,+ DailyTerminalStatisticRecord,+ DailyTokenCostStatisticRecord,+ TokensPerSecondStatisticRecord,+ UserSatisfactionRateStatisticRecord,+)+++class _RecordingRepository(AppStatisticQueryRepository):+ def __init__(self) -> None:+ super().__init__(session_factory=cast(sessionmaker[Session], object()))+ self.rows: tuple[RowMapping, ...] = ()+ self.calls: list[tuple[str, dict[str, object]]] = []++ @override+ def _execute(self, sql_query: str, parameters: dict[str, object]) -> tuple[RowMapping, ...]:+ self.calls.append((sql_query, parameters.copy()))+ return self.rows+++def _row(**values: object) -> RowMapping:+ return cast(RowMapping, values)+++def test_app_statistic_repository_maps_results_and_preserves_query_scope(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setattr(repository_module, "convert_datetime_to_date", lambda field: field)+ repository = _RecordingRepository()+ start_date = datetime(2024, 1, 1, tzinfo=UTC)+ end_date = datetime(2024, 1, 2, tzinfo=UTC)++ repository.rows = (_row(date="2024-01-01", message_count=2),)+ assert repository.get_daily_messages(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (DailyMessageStatisticRecord(date="2024-01-01", message_count=2),)++ repository.rows = (_row(date="2024-01-01", conversation_count=3),)+ assert repository.get_daily_conversations(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (DailyConversationStatisticRecord(date="2024-01-01", conversation_count=3),)++ repository.rows = (_row(date="2024-01-01", terminal_count=4),)+ assert repository.get_daily_terminals(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (DailyTerminalStatisticRecord(date="2024-01-01", terminal_count=4),)++ repository.rows = (_row(date="2024-01-01", token_count=Decimal(5), total_price=Decimal("0.25")),)+ assert repository.get_daily_token_costs(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (+ DailyTokenCostStatisticRecord(+ date="2024-01-01",+ token_count=5,+ total_price=Decimal("0.25"),+ currency="USD",+ ),+ )++ repository.rows = (_row(date="2024-01-01", interactions=Decimal("2.345")),)+ assert repository.get_average_session_interactions(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (AverageSessionInteractionStatisticRecord(date="2024-01-01", interactions=2.34),)++ repository.rows = (_row(date="2024-01-01", message_count=10, feedback_count=1),)+ assert repository.get_user_satisfaction_rates(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (UserSatisfactionRateStatisticRecord(date="2024-01-01", rate=100.0),)++ repository.rows = (_row(date="2024-01-01", latency=1.234),)+ assert repository.get_average_response_times(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (AverageResponseTimeStatisticRecord(date="2024-01-01", latency=1234.0),)++ repository.rows = (_row(date="2024-01-01", tokens_per_second=15.55555),)+ assert repository.get_tokens_per_second(+ app_id="app-1",+ start_date=start_date,+ end_date=end_date,+ timezone="Asia/Shanghai",+ ) == (TokensPerSecondStatisticRecord(date="2024-01-01", tps=15.5556),)++ assert len(repository.calls) == 8+ for sql_query, parameters in repository.calls:+ assert "created_at >= :start_date" in sql_query+ assert "created_at < :end_date" in sql_query+ assert parameters == {+ "tz": "Asia/Shanghai",+ "app_id": "app-1",+ "excluded_invoke_from": InvokeFrom.DEBUGGER,+ "start_date": start_date,+ "end_date": end_date,+ }+++def test_daily_messages_omit_time_range_when_not_provided(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setattr(repository_module, "convert_datetime_to_date", lambda field: field)+ repository = _RecordingRepository()++ assert (+ repository.get_daily_messages(+ app_id="app-1",+ start_date=None,+ end_date=None,+ timezone="Asia/Shanghai",+ )+ == ()+ )++ sql_query, parameters = repository.calls[0]+ assert ":start_date" not in sql_query+ assert ":end_date" not in sql_query+ assert parameters == {+ "tz": "Asia/Shanghai",+ "app_id": "app-1",+ "excluded_invoke_from": InvokeFrom.DEBUGGER,+ }