quapp-common 0.0.13.dev7__tar.gz → 0.0.13.dev9__tar.gz

{quapp_common-0.0.13.dev7/quapp_common.egg-info → quapp_common-0.0.13.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.13.dev7
+Version: 0.0.13.dev9
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -114,6 +114,78 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.14.dev1 — Error logging & observability (Phase 0)
+
+Mục tiêu: Function Log và Job Log phải chỉ ra được nguyên nhân lỗi. Toàn bộ thay
+đổi trong bản này là **additive hoặc bug fix** — không đổi contract callback,
+không đổi schema `job_result`, không cần frontend/backend sửa gì.
+
+**Logging (`config/`)**
+- Thêm `config/log_context.py`: `bind_job()` / `enrich_job_context()` đặt
+  `job_id`, `trace_id`, `sdk`, `provider`, `device` vào `contextvars`. Mọi log
+  sau đó tự có đủ field, kể cả log của `Provider` / `DeviceSelection` /
+  `*Factory` — những chỗ trước đây rơi vào context `"QuappLibs"` nên không gắn
+  được vào job nào.
+- `configure_logging()` **idempotent**. Trước đây `AsyncInvocationTask.do()` gọi
+  `logger.add(sink=sys.stderr, ...)` cho mỗi request, nên sau N job có N+1 sink
+  và mỗi dòng log in N+1 lần.
+- Thêm `InterceptHandler` + `install_stdlib_intercept()`: đẩy mọi record của
+  stdlib `logging` sang loguru. Cần thiết vì 24/34 template trong
+  `quapp-sdk-templates` dùng `logging.getLogger('index')` mà không cấu hình
+  handler — `debug`/`info` của chúng bị drop im lặng và `exception` in ra không
+  có prefix `[ConsoleJobLog]` lẫn `job_id`. Log của uvicorn/qiskit/botocore cũng
+  về cùng một format.
+- Thêm JSON sink cho structured logging, bật bằng `QUAPP_LOG_FORMAT=json|both`
+  (default `text`, giữ nguyên hành vi cũ). Field: `jobId`, `traceId`, `phase`,
+  `category`, `errorCode`, `sdk`, `provider`, `device`, `event`, `durationMs`.
+- Thêm redaction filter: mask `token` / `apiKey` / `authentication` /
+  `clientSecret` / … trước khi ghi log, áp dụng cả cho stack trace.
+- Fix: text formatter thiếu `{exception}`. Với formatter dạng callable, loguru
+  **không** tự append traceback — nên trước đây mọi `logger.exception()` trong
+  codebase không in ra stack trace nào.
+- Fix: `depth` trong intercept khiến mọi record hiện là
+  `logging:callHandlers:<line>` thay vì file:line của nơi gọi log.
+- Fix: với `enqueue=True`, traceback object không picklable nên bị thay bằng
+  `None` sau khi qua queue. Traceback nay được format sẵn ở filter.
+
+**Error từ runner không phải Python (`component/dispatcher.py`, `bridge.py`)**
+- Bỏ `subprocess.run(..., check=True)`. Nó raise `CalledProcessError` **trước
+  khi** đọc được output, làm nhánh `_extract_error_message()` thành dead code và
+  user chỉ thấy `Command '[...]' returned non-zero exit status 1`.
+- Thêm `HandlerRuntimeError` mang `language`, `action`, `error_type`, `stack`
+  (stack của runtime gốc — JS/.NET), `exit_code`, `signal_name`. Sáu tình huống
+  được phân biệt: runner không có trong image, timeout, bị signal (handler.c
+  segfault → returncode âm, stdout rỗng), structured error trên stdout, exit
+  code khác 0, và output không phải JSON hợp lệ.
+- Đọc được **cả contract cũ** (`error` dạng string, stack trên stderr) nên không
+  cần deploy đồng thời với template.
+- `_format_exception()` đưa `handlerStackTrace` / `language` / `action` /
+  `exitCode` / `signal` lên `job_result` cho lỗi handler JS/Q#/C.
+
+**Đường lỗi (`model/device/device.py`, `util/response_utils.py`, …)**
+- `Device._on_execution` dùng `build_error_job_response()` thay cho
+  `job_result = {"error": str(exception)}` và log ở `ERROR` thay vì `DEBUG`.
+  Đây là đường lỗi quan trọng nhất (submit circuit lên device) và trước đây là
+  đường mất thông tin nhiều nhất.
+- `build_error_job_response()` nay tự phát một log `ERROR` duy nhất cho mọi lỗi,
+  nên Job Log và Function Log không còn lệch nhau.
+- Truyền `stage` cho 8 call-site còn thiếu (trước đây 10/13 call-site rơi vào
+  default `'while running your job'`).
+- Fix `generate_response()`: nhánh `else` truy cập `job_response.status_code`
+  khi `job_response` là falsy → `AttributeError`, thay lỗi gốc bằng lỗi khác.
+- Fix `job_fetching.py`: `__produce_histogram_data` / `__get_execution_time`
+  khai báo `@staticmethod` nhưng dùng `self.logger` → `NameError` khi được gọi.
+- `DeviceSelection`: không log nguyên response (chứa token provider) và không
+  nhét `response.content` thô vào exception (nội dung này chảy vào `job_result`
+  rồi hiện lên UI).
+- `PostProcessingTask`: bỏ `print()` ghi thẳng ra stdout (không qua sink nên
+  không được redact và không có `job_id`).
+
+**Test**
+- `tests/test_logging_config.py` — redaction, idempotent sink, job context,
+  intercept stdlib, exception payload.
+- `tests/test_dispatcher_runner_error.py` — 6 nhánh phân loại lỗi runner.
+
 ### v0.0.13.dev2
 - Fix: `_openqasm_to_braket` in `circuit_adapter.py` now injects a default
   `Probability` result type when the Braket circuit produced by `tk_to_braket`

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/README.md

@@ -73,6 +73,78 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.14.dev1 — Error logging & observability (Phase 0)
+
+Mục tiêu: Function Log và Job Log phải chỉ ra được nguyên nhân lỗi. Toàn bộ thay
+đổi trong bản này là **additive hoặc bug fix** — không đổi contract callback,
+không đổi schema `job_result`, không cần frontend/backend sửa gì.
+
+**Logging (`config/`)**
+- Thêm `config/log_context.py`: `bind_job()` / `enrich_job_context()` đặt
+  `job_id`, `trace_id`, `sdk`, `provider`, `device` vào `contextvars`. Mọi log
+  sau đó tự có đủ field, kể cả log của `Provider` / `DeviceSelection` /
+  `*Factory` — những chỗ trước đây rơi vào context `"QuappLibs"` nên không gắn
+  được vào job nào.
+- `configure_logging()` **idempotent**. Trước đây `AsyncInvocationTask.do()` gọi
+  `logger.add(sink=sys.stderr, ...)` cho mỗi request, nên sau N job có N+1 sink
+  và mỗi dòng log in N+1 lần.
+- Thêm `InterceptHandler` + `install_stdlib_intercept()`: đẩy mọi record của
+  stdlib `logging` sang loguru. Cần thiết vì 24/34 template trong
+  `quapp-sdk-templates` dùng `logging.getLogger('index')` mà không cấu hình
+  handler — `debug`/`info` của chúng bị drop im lặng và `exception` in ra không
+  có prefix `[ConsoleJobLog]` lẫn `job_id`. Log của uvicorn/qiskit/botocore cũng
+  về cùng một format.
+- Thêm JSON sink cho structured logging, bật bằng `QUAPP_LOG_FORMAT=json|both`
+  (default `text`, giữ nguyên hành vi cũ). Field: `jobId`, `traceId`, `phase`,
+  `category`, `errorCode`, `sdk`, `provider`, `device`, `event`, `durationMs`.
+- Thêm redaction filter: mask `token` / `apiKey` / `authentication` /
+  `clientSecret` / … trước khi ghi log, áp dụng cả cho stack trace.
+- Fix: text formatter thiếu `{exception}`. Với formatter dạng callable, loguru
+  **không** tự append traceback — nên trước đây mọi `logger.exception()` trong
+  codebase không in ra stack trace nào.
+- Fix: `depth` trong intercept khiến mọi record hiện là
+  `logging:callHandlers:<line>` thay vì file:line của nơi gọi log.
+- Fix: với `enqueue=True`, traceback object không picklable nên bị thay bằng
+  `None` sau khi qua queue. Traceback nay được format sẵn ở filter.
+
+**Error từ runner không phải Python (`component/dispatcher.py`, `bridge.py`)**
+- Bỏ `subprocess.run(..., check=True)`. Nó raise `CalledProcessError` **trước
+  khi** đọc được output, làm nhánh `_extract_error_message()` thành dead code và
+  user chỉ thấy `Command '[...]' returned non-zero exit status 1`.
+- Thêm `HandlerRuntimeError` mang `language`, `action`, `error_type`, `stack`
+  (stack của runtime gốc — JS/.NET), `exit_code`, `signal_name`. Sáu tình huống
+  được phân biệt: runner không có trong image, timeout, bị signal (handler.c
+  segfault → returncode âm, stdout rỗng), structured error trên stdout, exit
+  code khác 0, và output không phải JSON hợp lệ.
+- Đọc được **cả contract cũ** (`error` dạng string, stack trên stderr) nên không
+  cần deploy đồng thời với template.
+- `_format_exception()` đưa `handlerStackTrace` / `language` / `action` /
+  `exitCode` / `signal` lên `job_result` cho lỗi handler JS/Q#/C.
+
+**Đường lỗi (`model/device/device.py`, `util/response_utils.py`, …)**
+- `Device._on_execution` dùng `build_error_job_response()` thay cho
+  `job_result = {"error": str(exception)}` và log ở `ERROR` thay vì `DEBUG`.
+  Đây là đường lỗi quan trọng nhất (submit circuit lên device) và trước đây là
+  đường mất thông tin nhiều nhất.
+- `build_error_job_response()` nay tự phát một log `ERROR` duy nhất cho mọi lỗi,
+  nên Job Log và Function Log không còn lệch nhau.
+- Truyền `stage` cho 8 call-site còn thiếu (trước đây 10/13 call-site rơi vào
+  default `'while running your job'`).
+- Fix `generate_response()`: nhánh `else` truy cập `job_response.status_code`
+  khi `job_response` là falsy → `AttributeError`, thay lỗi gốc bằng lỗi khác.
+- Fix `job_fetching.py`: `__produce_histogram_data` / `__get_execution_time`
+  khai báo `@staticmethod` nhưng dùng `self.logger` → `NameError` khi được gọi.
+- `DeviceSelection`: không log nguyên response (chứa token provider) và không
+  nhét `response.content` thô vào exception (nội dung này chảy vào `job_result`
+  rồi hiện lên UI).
+- `PostProcessingTask`: bỏ `print()` ghi thẳng ra stdout (không qua sink nên
+  không được redact và không có `job_id`).
+
+**Test**
+- `tests/test_logging_config.py` — redaction, idempotent sink, job context,
+  intercept stdlib, exception payload.
+- `tests/test_dispatcher_runner_error.py` — 6 nhánh phân loại lỗi runner.
+
 ### v0.0.13.dev2
 - Fix: `_openqasm_to_braket` in `circuit_adapter.py` now injects a default
   `Probability` result type when the Braket circuit produced by `tk_to_braket`

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.13.dev7"
+version = "0.0.13.dev9"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/async_tasks/async_invocation_task.py

@@ -2,7 +2,6 @@
 #  async_invocation_task.py
 #  Copyright © CITYNOW Co. Ltd. All rights reserved.
 import asyncio
-import sys
 
 from starlette.concurrency import run_in_threadpool
 from starlette.responses import JSONResponse
@@ -10,6 +9,7 @@ from starlette.responses import JSONResponse
 from ..async_tasks.async_task import AsyncTask
 from ..component.backend.job_manager import JobManager
 from ..component.callback.update_job_metadata import update_job_metadata
+from ..config.log_context import bind_job
 from ..config.logging_config import logger
 from ..factory.handler_factory import HandlerFactory
 from ..model.invocation import Event, Error, Success
@@ -61,9 +61,12 @@ class AsyncInvocationTask(AsyncTask):
             job_id = self.event.json().get('jobId')
             if job_id is None:
                 raise Exception("Job ID is missing from event")
-            logger.add(sink=sys.stderr,
-                       format="[ConsoleJobLog][" + job_id + "] " + "{level} : {time} : {message}: {process}",
-                       level='DEBUG')
+
+            # Trước đây chỗ này gọi logger.add(sink=sys.stderr, ...) cho MỖI
+            # request: sau N job có N+1 sink và mỗi dòng log in N+1 lần. Sink đã
+            # được cấu hình một lần trong logging_config; ở đây chỉ cần bind
+            # context để mọi log sau đó tự có job_id/trace_id.
+            job_log = bind_job(job_id)
 
             # Define the blocking work
             def _run_handle():
@@ -78,7 +81,7 @@ class AsyncInvocationTask(AsyncTask):
                 if t.cancelled() or t.exception() is None:
                     return
                 exc = t.exception()
-                logger.exception(
+                job_log.bind(event='background_task_failed').exception(
                         f"Background job task failed for job {job_id}: {exc}")
                 try:
                     event_data = self.event.json()
@@ -87,7 +90,8 @@ class AsyncInvocationTask(AsyncTask):
                     if on_error_url:
                         error_response = build_error_job_response(
                                 exc,
-                                message=f"Unhandled background task error: {exc}")
+                                message=f"Unhandled background task error: {exc}",
+                                stage='while running your job in the background')
                         error_response.user_token = event_data.get('userToken')
                         error_response.user_identity = event_data.get(
                                 'userIdentity')
@@ -97,7 +101,7 @@ class AsyncInvocationTask(AsyncTask):
                                 event_data, 'workspaceHeader')
                         update_job_metadata(error_response, on_error_url)
                 except Exception as fallback_exc:
-                    logger.exception(
+                    job_log.bind(event='callback_failed').exception(
                             f"Failed to notify BE of error for job {job_id}: {fallback_exc}")
 
             task.add_done_callback(_on_task_done)

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/async_tasks/post_processing_task.py

@@ -35,15 +35,22 @@ class PostProcessingTask(AsyncTask):
             job_result_post_processing = self.post_processing_fn(
                     self.promise.job_result)
 
-            self.logger.debug("Parsing job result....")
-            print(job_result_post_processing)
+            # print() cũ ghi thẳng ra stdout, không qua sink nên không được
+            # redact và không có job_id.
+            self.logger.debug(
+                    f"Parsing job result: type={type(job_result_post_processing).__name__}")
             job_response.job_result = parse(job_result_post_processing)
 
             update_job_metadata(job_response, self.promise.callback_url.on_done)
 
         except Exception as exception:
-            job_response = build_error_job_response(exception, job_response,
-                                                    message='Error when post processing job result')
+            self.logger.bind(event='job_failed').exception(
+                    f"Post-processing failed: {exception}")
+
+            job_response = build_error_job_response(
+                    exception, job_response,
+                    message='Error when post processing job result',
+                    stage='while post-processing the job result')
 
             update_job_metadata(job_response,
                                 self.promise.callback_url.on_error)

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/component/backend/job_fetcher.py

@@ -131,9 +131,11 @@ class JobFetcher(ABC):
                     f"Exception during job fetch for provider_job_id {self.provider_job_id}: {exception}",
                     exc_info=True)
 
-            job_response = build_error_job_response(exception, job_response,
-                                                    message='Error when fetching job with provider_job_id {0}'.format(
-                                                            self.provider_job_id))
+            job_response = build_error_job_response(
+                    exception, job_response,
+                    message='Error when fetching job with provider_job_id {0}'.format(
+                            self.provider_job_id),
+                    stage='while fetching the job result from the provider')
             update_job_metadata(job_response, self.callback_urls[
                 InvocationStep.EXECUTION].on_error)
 
@@ -208,8 +210,10 @@ class JobFetcher(ABC):
             self.logger.exception(f"Exception during analysis: {exception}",
                               exc_info=True)
             from ...util.response_utils import build_error_job_response
-            job_response = build_error_job_response(exception, job_response,
-                                                    message='Error when analyzing job result')
+            job_response = build_error_job_response(
+                    exception, job_response,
+                    message='Error when analyzing job result',
+                    stage='while analysing the job result')
 
             update_job_metadata(job_response, callback_url.on_error)
             return None

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/component/backend/job_fetching.py

@@ -89,13 +89,15 @@ class JobFetching(ABC):
                 job_response.status_code = StatusCode.POLLING
 
         except Exception as exception:
-            self.logger.debug(
+            self.logger.bind(event='job_failed').exception(
                     "Exception when fetch job with provider_job_id {0}: {1}".format(
                             self.provider_job_id, str(exception)))
 
-            job_response = build_error_job_response(exception, job_response,
-                                                    message='Exception when fetch job with provider_job_id {0}'.format(
-                                                            self.provider_job_id))
+            job_response = build_error_job_response(
+                    exception, job_response,
+                    message='Exception when fetch job with provider_job_id {0}'.format(
+                            self.provider_job_id),
+                    stage='while fetching the job result from the provider')
 
             update_job_metadata(job_response, self.callback_dict.get(
                     InvocationStep.EXECUTION).on_error)
@@ -156,9 +158,11 @@ class JobFetching(ABC):
                     "Exception when analyst job result with provider_job_id {0}: {1}".format(
                             self.provider_job_id, str(exception)))
 
-            job_response = build_error_job_response(exception, job_response,
-                                                    message='Exception when analyst job result with provider_job_id {0}'.format(
-                                                            self.provider_job_id))
+            job_response = build_error_job_response(
+                    exception, job_response,
+                    message='Exception when analyst job result with provider_job_id {0}'.format(
+                            self.provider_job_id),
+                    stage='while analysing the job result')
 
             update_job_metadata(job_response, callback_url.on_error)
 
@@ -183,8 +187,10 @@ class JobFetching(ABC):
         PostProcessingTask(post_processing_fn=post_processing_fn,
                            promise=promise).do()
 
-    @staticmethod
-    def __produce_histogram_data(job_result) -> Any | None:
+    # Trước đây hai method dưới là @staticmethod nhưng vẫn dùng `self.logger`,
+    # nên chúng raise NameError ngay khi được gọi -- biến lỗi analysis thành một
+    # lỗi vô nghĩa hoàn toàn khác. Bỏ @staticmethod để `self` hợp lệ.
+    def __produce_histogram_data(self, job_result) -> Any | None:
         """
 
         @param job_result:
@@ -196,14 +202,13 @@ class JobFetching(ABC):
             histogram_data = job_result.result()[0].data.meas.get_counts()
 
         except Exception as e:
-            self.logger.debug(
+            self.logger.warning(
                     "Can't produce histogram with error: {0}".format(str(e)))
             histogram_data = None
 
         return histogram_data
 
-    @staticmethod
-    def __get_execution_time(job_result):
+    def __get_execution_time(self, job_result):
         """
 
         @param job_result:

quapp_common-0.0.13.dev9/quapp_common/component/backend/job_heartbeat.py

@@ -0,0 +1,83 @@
+#  Quapp Platform Project
+#  job_heartbeat.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import os
+import threading
+
+import requests
+
+from ...config.logging_config import logger
+
+DEFAULT_INTERVAL_SEC = 30.0
+REQUEST_TIMEOUT_SEC = 5.0
+TERMINAL_STATUSES = ('DONE', 'FAILED')
+
+_lock = threading.Lock()
+_thread = None
+_stop_event = threading.Event()
+
+
+def heartbeat_interval_sec() -> float:
+    raw = os.getenv('HEARTBEAT_INTERVAL_SEC', '')
+    try:
+        value = float(raw)
+        if value > 0:
+            return value
+    except ValueError:
+        pass
+    return DEFAULT_INTERVAL_SEC
+
+
+def beat_once() -> int:
+    from .job_manager import JobManager, META, STATUS, SCHEDULER_CALLBACK_URL
+
+    sent = 0
+    for job_id, data in JobManager.list_jobs().items():
+        if data.get(STATUS) in TERMINAL_STATUSES:
+            continue
+        url = (data.get(META) or {}).get(SCHEDULER_CALLBACK_URL)
+        if not url:
+            continue
+        try:
+            response = requests.patch(
+                    url, json={'status': 'RUNNING', 'heartbeat': True},
+                    timeout=REQUEST_TIMEOUT_SEC)
+            logger.debug(
+                    f'Heartbeat for job {job_id} returned {response.status_code}')
+            sent += 1
+        except Exception as exception:
+            logger.debug(f'Heartbeat for job {job_id} failed: {exception}')
+    return sent
+
+
+def _run() -> None:
+    while True:
+        try:
+            beat_once()
+        except Exception as exception:
+            logger.exception(f'Heartbeat loop error: {exception}')
+        if _stop_event.wait(heartbeat_interval_sec()):
+            return
+
+
+def ensure_started() -> None:
+    global _thread
+    with _lock:
+        if _thread is not None and _thread.is_alive():
+            return
+        _stop_event.clear()
+        _thread = threading.Thread(target=_run, name='job-heartbeat',
+                                   daemon=True)
+        _thread.start()
+        logger.info(
+                f'Job heartbeat started with interval {heartbeat_interval_sec()}s')
+
+
+def stop() -> None:
+    global _thread
+    with _lock:
+        _stop_event.set()
+        if _thread is not None:
+            _thread.join(timeout=1.0)
+        _thread = None

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/component/backend/job_manager.py

@@ -66,6 +66,9 @@ class JobManager:
         """
         Stop any listener threads in this process and shutdown Manager.
         """
+        from .job_heartbeat import stop
+        stop()
+
         # stop listeners
         for key, (t, stop_ev) in list(cls._listener_threads.items()):
             stop_ev.set()
@@ -100,6 +103,9 @@ class JobManager:
         cls._jobs[job_id] = data  # proxy is process-safe
         cls._publish(job_id, {"event": "added", **data})
 
+        from .job_heartbeat import ensure_started
+        ensure_started()
+
     @classmethod
     def update_status(cls, job_id: str, status: str,
                       meta_update: Optional[Dict[str, Any]] = None) -> None:

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/component/bridge.py

@@ -4,7 +4,7 @@
 from typing import Any, Dict
 
 from .circuit_adapter import adapt
-from .dispatcher import dispatch
+from .dispatcher import HandlerRuntimeError, dispatch
 from .result_serializer import serialize
 from ..config.logging_config import logger
 from ..enum.language import Language
@@ -47,25 +47,27 @@ class SubprocessBridge:
         logger.info(f"SubprocessBridge.processing: dispatching to {self.language.value} | sdk={self.sdk}")
         logger.debug(f"SubprocessBridge.processing: input_keys={list(invocation_input.keys())}")
 
+        # dispatch() đã raise HandlerRuntimeError cho mọi trường hợp lỗi
+        # (structured error, exit code khác 0, signal, output không hợp lệ) với
+        # đầy đủ error_type / stack của runner, nên ở đây không cần kiểm
+        # status == "error" nữa.
         result = dispatch(self.language, {
             "action": "processing",
             "input": invocation_input
         })
 
-        status = result.get("status")
-        logger.debug(f"SubprocessBridge.processing: JS status={status}")
-
-        if status == "error":
-            logger.error(f"SubprocessBridge.processing: JS error={result.get('error')}")
-            raise RuntimeError(f"JS processing failed: {result.get('error')}")
-
         payload = result.get("result")
         if payload is None:
-            raise RuntimeError("JS processing returned no 'result' field")
+            raise HandlerRuntimeError(
+                    language=self.language.value, action='processing',
+                    error_type='InvalidOutput',
+                    message="Handler không trả về field 'result'.")
         if not isinstance(payload, dict):
-            raise RuntimeError(
-                    f"JS processing returned invalid 'result' type: {type(payload).__name__}"
-            )
+            raise HandlerRuntimeError(
+                    language=self.language.value, action='processing',
+                    error_type='InvalidOutput',
+                    message=f"Field 'result' phải là object, nhận được "
+                            f"{type(payload).__name__}.")
 
         fmt = payload.get("format")
         logger.debug(f"SubprocessBridge.processing: JS returned format={fmt}; adapting for sdk={self.sdk}")
@@ -98,16 +100,12 @@ class SubprocessBridge:
             "job_result": serialized
         })
 
-        status = result.get("status")
-        logger.debug(f"SubprocessBridge.post_processing: JS status={status}")
-
-        if status == "error":
-            logger.error(f"SubprocessBridge.post_processing: JS error={result.get('error')}")
-            raise RuntimeError(f"JS post_processing failed: {result.get('error')}")
-
         payload = result.get("result")
         if payload is None:
-            raise RuntimeError("JS post_processing returned no 'result' field")
+            raise HandlerRuntimeError(
+                    language=self.language.value, action='post_processing',
+                    error_type='InvalidOutput',
+                    message="Handler không trả về field 'result'.")
 
         logger.info(f"SubprocessBridge.post_processing: completed successfully | result type={type(payload).__name__}")
         return payload

{quapp_common-0.0.13.dev7 → quapp_common-0.0.13.dev9}/quapp_common/component/device/device_selection.py

@@ -60,21 +60,31 @@ class DeviceSelection:
         response = requests.get(self.url, params=request, headers=header)
 
         if response.status_code != 200:
-            logger.error(
-                    'Select device fail with status code: {0} and content: {1}'.format(
-                            response.status_code, response.content))
+            logger.bind(event='device_selection_failed',
+                        status_code=response.status_code).error(
+                    'Select device fail with status code: {0}'.format(
+                            response.status_code))
 
-            raise ValueError(f"Select device failed: {response.content}")
+            # Không đưa response.content thô vào exception: nội dung này chảy
+            # vào job_result rồi hiện lên UI, và có thể mang theo credential.
+            raise ValueError(
+                    f'Select device failed with status code '
+                    f'{response.status_code}. Xem Function Log để biết chi tiết.')
 
         try:
             response_dict = response.json().get("data")
 
+            # response_dict chứa cả `authentication` = token của provider, nên
+            # chỉ log các field không phải secret.
             logger.debug(
-                    'Select device successfully: {0}'.format(response_dict))
+                    'Select device successfully: providerTag={0}, deviceName={1}'.format(
+                            response_dict.get("providerTag"),
+                            response_dict.get("deviceName")))
 
             return BackendInformation(provider_tag=ProviderTag.resolve(
                     response_dict.get("providerTag")),
                     device_name=response_dict.get("deviceName"),
                     authentication=response_dict.get("authentication"))
         except JSONDecodeError:
+            logger.warning('Select device response is not valid JSON')
             return None