zrb 0.9.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

zrb/__init__.py

@@ -28,6 +28,7 @@ from zrb.task.resource_maker import Replacement, ReplacementMutator, ResourceMak
 from zrb.task.rsync_task import RsyncTask
 from zrb.task.task import Task
 from zrb.task.time_watcher import TimeWatcher
+from zrb.task.wiki_task import create_wiki_tasks
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
@@ -40,6 +41,7 @@ from zrb.task_input.password_input import PasswordInput
 from zrb.task_input.str_input import StrInput
 from zrb.task_input.task_input import Input
 
+assert create_wiki_tasks
 assert runner
 assert AnyTask
 assert OnTriggered

zrb/builtin/generator/docker_compose_task/template/src/kebab-zrb-task-name/image/Dockerfile

@@ -1,6 +1,7 @@
 FROM python:3.10-slim
 ENV APP_MESSAGE "Hello, world!"
 ENV APP_PORT 8080
+ENV POETRY_VIRTUAL_ENVS_CREATE=false
 WORKDIR /home
 COPY ./pyproject.toml ./pyproject.toml
 RUN pip install "poetry==1.7.1"

zrb/builtin/generator/docker_compose_task/template/src/kebab-zrb-task-name/image/pyproject.toml

@@ -13,7 +13,7 @@ uvicorn = "==0.20.0"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~7.0.0"
-black = "~24.2.0"
+black = "~24.3.0"
 isort = "~5.13.2"
 pytest = "~7.4.0"
 pytest-cov = "~4.1.0"

zrb/builtin/generator/fastapp/add.py

@@ -85,11 +85,23 @@ copy_resource = ResourceMaker(
     excludes=[
         "*/__pycache__",
         "*/deployment/venv",
-        "*/src/kebab-app-name/.venv",
-        "*/src/kebab-app-name/src/frontend/node_modules",
-        "*/src/kebab-app-name/src/frontend/build",
-        "*/src/kebab-app-name/src/frontend/.svelte-kit",
-        "*/src/kebab-app-name/monitoring/clickhouse",
+        "*/src/kebab-zrb-app-name/.venv",
+        "*/src/kebab-zrb-app-name/src/frontend/node_modules",
+        "*/src/kebab-zrb-app-name/src/frontend/build",
+        "*/src/kebab-zrb-app-name/src/frontend/.svelte-kit",
+    ],
+    skip_parsing=[
+        "*.mp3",
+        "*.pdf",
+        "*.exe",
+        "*.dll",
+        "*.bin",
+        "*.iso",
+        "*.png",
+        "*.jpg",
+        "*.gif",
+        "*.ico",
+        "*/monitoring/clickhouse/user_scripts/histogramQuantile",
     ],
 )
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/loadtest/pyproject.toml

@@ -13,7 +13,7 @@ locust = "==2.16.1"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~6.0.0"
-black = "~23.12.1"
+black = "~24.3.0"
 isort = "~5.13.2"
 
 [build-system]

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/Dockerfile

@@ -8,6 +8,7 @@ RUN npm install --save-dev && npm run build
 FROM python:3.10-slim
 ENV APP_HOST 0.0.0.0
 ENV APP_PORT 8080
+ENV POETRY_VIRTUAL_ENVS_CREATE=false
 WORKDIR /home
 RUN apt update && apt install curl psmisc -y
 RUN pip install -U pip

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/config.py

@@ -14,7 +14,9 @@ app_reload = str_to_boolean(os.getenv("APP_RELOAD", "true"))
 app_max_not_ready = int(os.getenv("APP_MAX_NOT_READY", "10"))
 
 app_enable_otel = str_to_boolean(os.getenv("APP_ENABLE_OTEL", "false"))
-app_otel_exporter_otlp_endpoint = os.getenv("APP_OTEL_EXPORTER_OTLP_ENDPOINT", "false")
+app_otel_exporter_otlp_endpoint = os.getenv(
+    "APP_OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"
+)
 
 app_auth_access_token_cookie_key = os.getenv(
     "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/group/api.py

@@ -8,6 +8,9 @@ from module.auth.component import Authorizer
 from module.auth.integration import access_token_scheme
 from module.auth.schema.group import Group, GroupData, GroupResult
 from module.auth.schema.token import AccessTokenData
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
 
 
 def register_api(
@@ -26,20 +29,22 @@ def register_api(
         offset: int = 0,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:permission:get"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_get_group",
-                keyword=keyword,
-                criterion={},
-                limit=limit,
-                offset=offset,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return GroupResult(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_get_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_group",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return GroupResult(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -47,17 +52,19 @@ def register_api(
     async def get_group_by_id(
         id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:group:get_by_id"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_get_group_by_id",
-                id=id,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Group(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_get_group_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_group_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -65,17 +72,19 @@ def register_api(
     async def insert_group(
         data: GroupData, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:group:insert"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_insert_group",
-                data=data.model_dump(),
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Group(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_insert_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_group",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -85,18 +94,20 @@ def register_api(
         data: GroupData,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:group:update"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_update_group",
-                id=id,
-                data=data.model_dump(),
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Group(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_update_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_group",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -104,14 +115,18 @@ def register_api(
     async def delete_group(
         id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:group:delete"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_delete_group", id=id, user_token_data=user_token_data.model_dump()
-            )
-            return Group(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_delete_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_group",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/permission/api.py

@@ -8,6 +8,9 @@ from module.auth.component import Authorizer
 from module.auth.integration import access_token_scheme
 from module.auth.schema.permission import Permission, PermissionData, PermissionResult
 from module.auth.schema.token import AccessTokenData
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
 
 
 def register_api(
@@ -26,20 +29,22 @@ def register_api(
         offset: int = 0,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:permission:get"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_get_permission",
-                keyword=keyword,
-                criterion={},
-                limit=limit,
-                offset=offset,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return PermissionResult(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_get_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_permission",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PermissionResult(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -47,17 +52,19 @@ def register_api(
     async def get_permission_by_id(
         id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:permission:get_by_id"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_get_permission_by_id",
-                id=id,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Permission(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_get_permission_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_permission_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -66,17 +73,19 @@ def register_api(
         data: PermissionData,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:permission:insert"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_insert_permission",
-                data=data.model_dump(),
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Permission(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_insert_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_permission",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -86,18 +95,20 @@ def register_api(
         data: PermissionData,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:permission:update"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_update_permission",
-                id=id,
-                data=data.model_dump(),
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Permission(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_update_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_permission",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -105,16 +116,18 @@ def register_api(
     async def delete_permission(
         id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:permission:delete"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_delete_permission",
-                id=id,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return Permission(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_delete_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_permission",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/user/api.py

@@ -11,6 +11,9 @@ from module.auth.integration import access_token_scheme, bearer_token_scheme
 from module.auth.schema.request import IsAuthorizedRequest, RefreshTokenRequest
 from module.auth.schema.token import AccessTokenData, TokenResponse
 from module.auth.schema.user import User, UserData, UserLogin, UserResult
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
 
 
 def register_auth_api(
@@ -35,10 +38,11 @@ def register_auth_api(
 
     async def _create_token(data: UserLogin) -> TokenResponse:
         try:
-            token_response_dict = await rpc_caller.call(
-                "auth_create_token", login_data=data.model_dump()
-            )
-            return TokenResponse(**token_response_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_create_token"):
+                token_response_dict = await rpc_caller.call(
+                    "auth_create_token", login_data=data.model_dump()
+                )
+                return TokenResponse(**token_response_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -47,12 +51,13 @@ def register_auth_api(
         data: RefreshTokenRequest, refresh_token: str = Depends(bearer_token_scheme)
     ) -> TokenResponse:
         try:
-            token_response_dict = await rpc_caller.call(
-                "auth_refresh_token",
-                refresh_token=refresh_token,
-                access_token=data.access_token,
-            )
-            return TokenResponse(**token_response_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_refresh_token"):
+                token_response_dict = await rpc_caller.call(
+                    "auth_refresh_token",
+                    refresh_token=refresh_token,
+                    access_token=data.access_token,
+                )
+                return TokenResponse(**token_response_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -63,11 +68,12 @@ def register_auth_api(
     ) -> Mapping[str, str]:
         try:
             user_id = user_token_data.user_id
-            return await rpc_caller.call(
-                "auth_is_user_authorized",
-                id=user_id,
-                permission_name=data.permission_names,
-            )
+            with tracer.start_as_current_span("auth.rpc.auth_is_user_authorized"):
+                return await rpc_caller.call(
+                    "auth_is_user_authorized",
+                    id=user_id,
+                    permission_name=data.permission_names,
+                )
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -88,20 +94,22 @@ def register_api(
         offset: int = 0,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:user:get"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_get_user",
-                keyword=keyword,
-                criterion={},
-                limit=limit,
-                offset=offset,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return UserResult(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_get_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_user",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return UserResult(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -109,17 +117,19 @@ def register_api(
     async def get_user_by_id(
         id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:user:get_by_id"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_get_user_by_id",
-                id=id,
-                user_token_data=user_token_data.model_dump(),
-            )
-            return User(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_get_user_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_user_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -127,17 +137,19 @@ def register_api(
     async def insert_user(
         data: UserData, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:user:insert"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_insert_user",
-                data=data.model_dump(),
-                user_token_data=user_token_data.model_dump(),
-            )
-            return User(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_insert_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_user",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -147,18 +159,20 @@ def register_api(
         data: UserData,
         user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:user:update"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_update_user",
-                id=id,
-                data=data.model_dump(),
-                user_token_data=user_token_data.model_dump(),
-            )
-            return User(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_update_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_user",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
@@ -166,14 +180,18 @@ def register_api(
     async def delete_user(
         id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
-        if not await authorizer.is_having_permission(
-            user_token_data.user_id, "auth:user:delete"
-        ):
-            raise HTTPAPIException(403, "Unauthorized")
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
         try:
-            result_dict = await rpc_caller.call(
-                "auth_delete_user", id=id, user_token_data=user_token_data.model_dump()
-            )
-            return User(**result_dict)
+            with tracer.start_as_current_span("auth.rpc.auth_delete_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_user",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)