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.

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.py
index 48635166e3a..2ebf60bdcfe 100644
--- a/api/controllers/console/app/statistic.py
+++ b/api/controllers/console/app/statistic.py
@@ -1,31 +1,22 @@
+from datetime import datetime
from decimal import Decimal
-import sqlalchemy as sa
-from flask import abort
from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator
+from werkzeug.exceptions import BadRequest
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.console import console_ns
from 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_services
from fields.base import ResponseModel
from 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, AppMode
class 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.py
index 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 SQLAlchemyAccountRepository
from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.app_site_command_repository import AppSiteCommandRepository
+from repositories.app_statistic_query_repository import AppStatisticQueryRepository
from repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepository
from repositories.data_source_oauth_binding_repository import SQLAlchemyDataSourceOAuthBindingRepository
from repositories.explore_banner_query_repository import ExploreBannerQueryRepository
@@ -131,6 +132,7 @@ from services.account_password_service import AccountPasswordService
from services.account_profile_service import AccountProfileService
from services.app_definition_query_service import AppDefinitionQueryService
from services.app_site_service import AppSiteService
+from services.app_statistic_query import AppStatisticQuery
from services.auth.data_source_api_key_auth_gateways import (
ProviderApiKeyAuthCredentialValidator,
TenantApiKeyAuthCredentialEncryptor,
@@ -239,6 +241,7 @@ class ApplicationServices:
account_activation: AccountActivationService
app_definitions: AppDefinitionQueryService
app_sites: AppSiteService
+ app_statistics: AppStatisticQuery
billing_portal: BillingPortalService
compliance_downloads: ComplianceDownloadService
data_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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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, datetime
from decimal import Decimal
from inspect import unwrap
from types import SimpleNamespace
from typing import Any
+from unittest.mock import MagicMock
import pytest
from flask import Flask
from werkzeug.exceptions import BadRequest
from controllers.console.app import statistic as statistic_module
-from models.account import Account
+from machinery.context import RequestContext
from 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.py
index 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 SQLAlchemyAccountRepository
from repositories.app_site_command_repository import AppSiteCommandRepository
+from repositories.app_statistic_query_repository import AppStatisticQueryRepository
from repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository
from repositories.workflow_run_archive_repository import WorkflowRunArchiveBundleQueryRepository
from 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.py
new file mode 100644
index 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,
+ }