@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/logging_config.py

@@ -1,577 +0,0 @@
-"""Structlog configuration for Audit Orchestrator.
-
-Configures structlog with JSON support and contextvars for async-safe logging.
-Provides helper functions _handle_error and _emit_json per VDS standards.
-"""
-
-from __future__ import annotations
-
-import errno
-import json
-import logging
-import sys
-from collections.abc import MutableMapping
-from contextlib import contextmanager, suppress
-from contextvars import ContextVar
-from time import sleep
-from typing import Any, TextIO
-
-import structlog
-
-# Context variables for async correlation (audit_id, repo)
-audit_id_var: ContextVar[str | None] = ContextVar("audit_id", default=None)
-repo_var: ContextVar[str | None] = ContextVar("repo", default=None)
-check_id_var: ContextVar[str | None] = ContextVar("check_id", default=None)
-agent_var: ContextVar[str | None] = ContextVar("agent", default=None)
-phase_var: ContextVar[str | None] = ContextVar("phase", default=None)
-task_id_var: ContextVar[str | None] = ContextVar("task_id", default=None)
-trace_mode_var: ContextVar[bool] = ContextVar("trace_mode", default=False)
-
-_SENSITIVE_KEY_PARTS = {
-    "password",
-    "secret",
-    "token",
-    "api_key",
-    "apikey",
-    "authorization",
-    "bearer",
-    "access_key",
-    "refresh_token",
-    "client_secret",
-    "private_key",
-    "credential",
-    "cookie",
-    "session_id",
-    "auth_token",
-    "signature",
-    "passwd",
-    "ssh_key",
-    "_token",
-}
-
-_TRUNCATE_KEY_PARTS = {
-    "evidence",
-    "content",
-    "payload",
-    "response",
-    "prompt",
-    "body",
-    "text",
-    "html",
-    "diff",
-}
-
-_REDACTED_VALUE = "[REDACTED]"
-_TRUNCATE_LIMIT = 1000
-_MAX_DEPTH = 20
-_TRACE_TRUNCATE_LIMIT = 20_000
-_TRACE_MAX_DEPTH = 60
-_FILE_WRITER_FAILURE_COUNT = 0
-_FILE_WRITER_FAILURE_LOG_INTERVAL = 100
-_FILE_WRITER_MAX_RETRIES = 3
-_FILE_WRITER_RETRY_BACKOFF_SECONDS = 0.02
-
-
-def _errno_values(*names: str) -> frozenset[int]:
-    values = {value for name in names for value in [getattr(errno, name, None)] if isinstance(value, int)}
-    return frozenset(values)
-
-
-_FILE_WRITER_RETRYABLE_ERRNOS = _errno_values(
-    "EAGAIN",
-    "EWOULDBLOCK",
-    "EACCES",
-    "EBUSY",
-    "EINTR",
-    "EDEADLK",
-    "EPERM",
-)
-_FILE_WRITER_REOPEN_ERRNOS = _errno_values("EBADF")
-
-
-def _open_runtime_log_file(path: str) -> TextIO:
-    """Open runtime log file with line buffering for continuous JSONL writes."""
-    return open(path, "a", encoding="utf-8", buffering=1)
-
-
-def _should_reopen_runtime_log_handle(exc: Exception) -> bool:
-    if isinstance(exc, ValueError) and "closed file" in str(exc).lower():
-        return True
-    if isinstance(exc, OSError) and isinstance(exc.errno, int):
-        return exc.errno in _FILE_WRITER_REOPEN_ERRNOS
-    return False
-
-
-def _is_retryable_file_write_error(exc: Exception) -> bool:
-    if _should_reopen_runtime_log_handle(exc):
-        return True
-    if isinstance(exc, BlockingIOError):
-        return True
-    if isinstance(exc, OSError) and isinstance(exc.errno, int):
-        return exc.errno in _FILE_WRITER_RETRYABLE_ERRNOS
-    return False
-
-
-def _add_context_vars(
-    _logger: logging.Logger,
-    _method_name: str,
-    event_dict: MutableMapping[str, Any],
-) -> MutableMapping[str, Any]:
-    """Add contextvars to log event for async correlation.
-
-    Injects audit_id and repo from contextvars into each log entry.
-
-    Args:
-        logger: The wrapped logger object.
-        method_name: Name of the method called on the logger.
-        event_dict: Current event dictionary being logged.
-
-    Returns:
-        Updated event dictionary with context variables.
-    """
-    audit_id = audit_id_var.get()
-    repo = repo_var.get()
-    check_id = check_id_var.get()
-    agent = agent_var.get()
-    phase = phase_var.get()
-    task_id = task_id_var.get()
-
-    if audit_id is not None:
-        event_dict["audit_id"] = audit_id
-    if repo is not None:
-        event_dict["repo"] = repo
-    if check_id is not None:
-        event_dict["check_id"] = check_id
-    if agent is not None:
-        event_dict["agent"] = agent
-    if phase is not None:
-        event_dict["phase"] = phase
-    if task_id is not None:
-        event_dict["task_id"] = task_id
-
-    return event_dict
-
-
-def _process_structure(data: Any, depth: int = 0) -> Any:
-    """Recursively process structure to redact sensitive data and truncate.
-
-    Args:
-        data: The data to process.
-        depth: Current recursion depth.
-
-    Returns:
-        Processed data with sensitive fields redacted and large values truncated.
-    """
-    is_tracing = trace_mode_var.get()
-    truncate_limit = _TRACE_TRUNCATE_LIMIT if is_tracing else _TRUNCATE_LIMIT
-    max_depth = _TRACE_MAX_DEPTH if is_tracing else _MAX_DEPTH
-
-    if depth > max_depth:
-        return "..."
-
-    if isinstance(data, str):
-        if len(data) > truncate_limit:
-            return data[:truncate_limit] + "...(truncated)"
-        return data
-
-    if isinstance(data, (list, tuple)):
-        return [_process_structure(item, depth + 1) for item in data]
-
-    if isinstance(data, dict):
-        result = {}
-        for key, value in data.items():
-            if not isinstance(key, str):
-                result[key] = _process_structure(value, depth + 1)
-                continue
-
-            key_lower = key.lower()
-            if any(part in key_lower for part in _SENSITIVE_KEY_PARTS):
-                result[key] = _REDACTED_VALUE
-            elif any(part in key_lower for part in _TRUNCATE_KEY_PARTS):
-                result[key] = _process_structure(value, depth + 1)
-            else:
-                result[key] = _process_structure(value, depth + 1)
-        return result
-
-    return data
-
-
-def _redact_sensitive(
-    _logger: logging.Logger,
-    _method_name: str,
-    event_dict: MutableMapping[str, Any],
-) -> MutableMapping[str, Any]:
-    """Redact sensitive fields and truncate large payloads.
-
-    Uses recursive processing with depth protection.
-    """
-    processed = _process_structure(event_dict)
-    if isinstance(processed, dict):
-        return processed
-    return event_dict
-
-
-def _capture_logs(
-    _logger: logging.Logger,
-    _method_name: str,
-    event_dict: MutableMapping[str, Any],
-    *,
-    buffer: list[dict[str, Any]],
-) -> MutableMapping[str, Any]:
-    """Capture structured log events for debug bundles."""
-    buffer.append(dict(event_dict))
-    return event_dict
-
-
-def _file_writer(
-    _logger: logging.Logger,
-    _method_name: str,
-    event_dict: MutableMapping[str, Any],
-    *,
-    file_handle: TextIO | None,
-    file_state: MutableMapping[str, TextIO | None] | None = None,
-    log_file: str | None = None,
-) -> MutableMapping[str, Any]:
-    """Write log events to a file as JSON lines."""
-    global _FILE_WRITER_FAILURE_COUNT
-    active_handle = file_state.get("handle") if file_state is not None else file_handle
-    payload_line = json.dumps(event_dict, default=str, ensure_ascii=False) + "\n"
-
-    for attempt in range(_FILE_WRITER_MAX_RETRIES + 1):
-        try:
-            if active_handle is None or active_handle.closed:
-                if not log_file:
-                    raise ValueError("runtime log writer handle unavailable and log_file is not set")
-                active_handle = _open_runtime_log_file(log_file)
-                if file_state is not None:
-                    file_state["handle"] = active_handle
-
-            active_handle.write(payload_line)
-            active_handle.flush()
-            if attempt > 0:
-                print(
-                    f"runtime_log_file_write_recovered retries={attempt} path={log_file or '<unknown>'}",
-                    file=sys.stderr,
-                )
-            return event_dict
-        except Exception as exc:  # pragma: no cover - exercised via explicit unit tests
-            can_retry = bool(log_file) and attempt < _FILE_WRITER_MAX_RETRIES and _is_retryable_file_write_error(exc)
-            if can_retry:
-                if _should_reopen_runtime_log_handle(exc):
-                    try:
-                        if active_handle is not None and not active_handle.closed:
-                            active_handle.close()
-                    except Exception:
-                        pass
-                    active_handle = None
-                    if file_state is not None:
-                        file_state["handle"] = None
-                sleep(_FILE_WRITER_RETRY_BACKOFF_SECONDS * (attempt + 1))
-                continue
-
-            _FILE_WRITER_FAILURE_COUNT += 1
-            if _FILE_WRITER_FAILURE_COUNT == 1 or (_FILE_WRITER_FAILURE_COUNT % _FILE_WRITER_FAILURE_LOG_INTERVAL == 0):
-                print(
-                    "runtime_log_file_write_failed "
-                    f"count={_FILE_WRITER_FAILURE_COUNT} "
-                    f"retries={attempt} "
-                    f"path={log_file or '<unset>'} "
-                    f"error={type(exc).__name__}: {exc}",
-                    file=sys.stderr,
-                )
-            break
-    return event_dict
-
-
-def _handle_error(
-    _logger: logging.Logger,
-    _method_name: str,
-    event_dict: MutableMapping[str, Any],
-) -> MutableMapping[str, Any]:
-    """Handle error formatting for structured logs.
-
-    Extracts exception information and formats it appropriately for
-    JSON or console output. Includes error context for AuditOrchestratorError.
-    """
-    exc_info = event_dict.pop("exc_info", None)
-    if exc_info:
-        if isinstance(exc_info, BaseException):
-            event_dict["exception_type"] = type(exc_info).__name__
-            event_dict["exception_message"] = str(exc_info)
-            # Include context if it's an AuditOrchestratorError
-            if hasattr(exc_info, "context"):
-                context = exc_info.context
-                if context:
-                    event_dict["error_context"] = dict(context)
-        elif exc_info is not True:
-            # Handle tuple format from sys.exc_info()
-            event_dict["exc_info"] = exc_info
-
-    return event_dict
-
-
-def _emit_json(
-    _logger: logging.Logger,
-    _method_name: str,
-    event_dict: MutableMapping[str, Any],
-) -> str:
-    """Emit log event as JSON string for machine consumption."""
-    return json.dumps(event_dict, default=str, ensure_ascii=False)
-
-
-def configure_logging(
-    json_output: bool = False,
-    log_level: str = "INFO",
-    capture_logs: list[dict[str, Any]] | None = None,
-    log_file: str | None = None,
-) -> None:
-    """Configure structlog for the Audit Orchestrator.
-
-    Sets up structured logging with either JSON or console output format.
-    Configures processors for context variable injection and error handling.
-
-    Args:
-        json_output: If True, output logs as JSON. If False, use rich console format.
-        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL).
-        capture_logs: Optional list to append log events to (for debug bundles).
-        log_file: Optional path to write logs to (in addition to or instead of stderr).
-    """
-    # Set the log level
-    numeric_level = getattr(logging, log_level.upper(), logging.INFO)
-
-    # Common processors for all output formats
-    shared_processors: list[structlog.typing.Processor] = [
-        structlog.contextvars.merge_contextvars,
-        structlog.stdlib.add_log_level,
-        structlog.processors.TimeStamper(fmt="iso"),
-        _add_context_vars,
-        _redact_sensitive,
-        _handle_error,
-    ]
-
-    # Add capture capability if requested
-    if capture_logs is not None:
-        shared_processors.append(
-            lambda logger, method_name, event_dict: _capture_logs(logger, method_name, event_dict, buffer=capture_logs)
-        )
-
-    # Add file output capability if requested
-    if log_file:
-        try:
-            file_state: dict[str, TextIO | None] = {"handle": _open_runtime_log_file(log_file)}
-
-            def _runtime_log_file_processor(
-                logger: logging.Logger,
-                method_name: str,
-                event_dict: MutableMapping[str, Any],
-            ) -> MutableMapping[str, Any]:
-                return _file_writer(
-                    logger,
-                    method_name,
-                    event_dict,
-                    file_handle=file_state.get("handle"),
-                    file_state=file_state,
-                    log_file=log_file,
-                )
-
-            shared_processors.append(_runtime_log_file_processor)
-        except OSError as e:
-            print(f"Warning: Failed to open log file {log_file}: {e}", file=sys.stderr)
-
-    if json_output:
-        # JSON output for machine parsing (CI/CD, log aggregators)
-        processors: list[structlog.typing.Processor] = [
-            *shared_processors,
-            structlog.processors.format_exc_info,
-            _emit_json,
-        ]
-
-        structlog.configure(
-            processors=processors,
-            wrapper_class=structlog.make_filtering_bound_logger(numeric_level),
-            context_class=dict,
-            logger_factory=structlog.PrintLoggerFactory(file=sys.__stderr__),
-            cache_logger_on_first_use=False,
-        )
-    else:
-        # Rich console output for human readability
-        processors = [
-            *shared_processors,
-            structlog.processors.format_exc_info,
-            structlog.dev.ConsoleRenderer(colors=True),
-        ]
-
-        structlog.configure(
-            processors=processors,
-            wrapper_class=structlog.make_filtering_bound_logger(numeric_level),
-            context_class=dict,
-            logger_factory=structlog.PrintLoggerFactory(file=sys.__stderr__),
-            cache_logger_on_first_use=False,
-        )
-
-
-def set_trace_mode(enabled: bool) -> None:
-    """Enable or disable trace mode."""
-    trace_mode_var.set(enabled)
-
-
-def is_trace_mode_enabled() -> bool:
-    """Return whether trace mode is currently enabled."""
-    return bool(trace_mode_var.get())
-
-
-def set_audit_context(
-    audit_id: str | None = None,
-    repo: str | None = None,
-    check_id: str | None = None,
-    agent: str | None = None,
-    phase: str | None = None,
-    task_id: str | None = None,
-) -> None:
-    """Set context variables for correlation in async operations."""
-    if audit_id is not None:
-        audit_id_var.set(audit_id)
-    if repo is not None:
-        repo_var.set(repo)
-    if check_id is not None:
-        check_id_var.set(check_id)
-    if agent is not None:
-        agent_var.set(agent)
-    if phase is not None:
-        phase_var.set(phase)
-    if task_id is not None:
-        task_id_var.set(task_id)
-
-
-def clear_audit_context() -> None:
-    """Clear all audit context variables."""
-    audit_id_var.set(None)
-    repo_var.set(None)
-    check_id_var.set(None)
-    agent_var.set(None)
-    phase_var.set(None)
-    task_id_var.set(None)
-
-
-@contextmanager
-def log_context(**kwargs: str | None):
-    """Temporarily set log context vars and restore on exit."""
-    tokens = {}
-    baggage_values: dict[str, str] = {}
-    if "audit_id" in kwargs and kwargs["audit_id"] is not None:
-        tokens[audit_id_var] = audit_id_var.set(kwargs["audit_id"])
-        baggage_values["audit_id"] = str(kwargs["audit_id"])
-    if "repo" in kwargs and kwargs["repo"] is not None:
-        tokens[repo_var] = repo_var.set(kwargs["repo"])
-        baggage_values["repo"] = str(kwargs["repo"])
-    if "check_id" in kwargs and kwargs["check_id"] is not None:
-        tokens[check_id_var] = check_id_var.set(kwargs["check_id"])
-        baggage_values["check_id"] = str(kwargs["check_id"])
-    if "agent" in kwargs and kwargs["agent"] is not None:
-        tokens[agent_var] = agent_var.set(kwargs["agent"])
-        baggage_values["agent"] = str(kwargs["agent"])
-    if "phase" in kwargs and kwargs["phase"] is not None:
-        tokens[phase_var] = phase_var.set(kwargs["phase"])
-        baggage_values["phase"] = str(kwargs["phase"])
-    if "task_id" in kwargs and kwargs["task_id"] is not None:
-        tokens[task_id_var] = task_id_var.set(kwargs["task_id"])
-        baggage_values["task_id"] = str(kwargs["task_id"])
-    logfire_ctx = None
-    if baggage_values:
-        try:
-            import logfire
-
-            logfire_ctx = logfire.set_baggage(**baggage_values)
-            logfire_ctx.__enter__()
-        except Exception:
-            logfire_ctx = None
-    try:
-        yield
-    finally:
-        if logfire_ctx is not None:
-            with suppress(Exception):
-                logfire_ctx.__exit__(None, None, None)
-        for var, token in tokens.items():
-            var.reset(token)
-
-
-def get_logger(name: str) -> structlog.stdlib.BoundLogger:
-    """Get a structlog-bound logger with the specified name."""
-    return structlog.get_logger(name)
-
-
-# ---------------------------------------------------------------------------
-# Audit-context attribute propagation for OpenTelemetry spans.
-#
-# Phase 9d cleanup: the legacy ``vds_audit_orchestrator.observability.tracing``
-# wrapper module was deleted. The wrapper's only audit-specific value was
-# injecting these contextvars into every span it opened. That contract is
-# preserved by exposing two small primitives here, where the contextvars
-# already live:
-#
-#   - ``audit_trace_attrs(extra)`` — pure dict builder; returns the merged
-#     attribute dict (audit_id / repo / check_id / agent / phase / task_id
-#     filtered for None, then ``extra`` overlaid).
-#   - ``audit_otel_span(name, attributes)`` — context manager that opens an
-#     OpenTelemetry span on the shared ``vds_agent_core`` AgentTracer with
-#     the merged attributes. No-op when tracing is disabled.
-#
-# These are NOT a tracing wrapper class: they hold no state beyond the
-# AgentTracer singleton (owned by ``vds_agent_core.observability``) and
-# expose no API surface that duplicates AgentTracer.
-# ---------------------------------------------------------------------------
-
-_AUDIT_TRACE_VARS: tuple[tuple[str, ContextVar[str | None]], ...] = (
-    ("audit_id", audit_id_var),
-    ("repo", repo_var),
-    ("check_id", check_id_var),
-    ("agent", agent_var),
-    ("phase", phase_var),
-    ("task_id", task_id_var),
-)
-
-
-def audit_trace_attrs(extra: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Return audit context vars merged with ``extra`` (extra wins on conflict).
-
-    Pure data utility — no side effects, no tracing API. Suitable for any
-    OpenTelemetry-compatible attribute dict.
-    """
-    merged: dict[str, Any] = {}
-    for key, var in _AUDIT_TRACE_VARS:
-        value = var.get()
-        if value is not None:
-            merged[key] = value
-    if extra:
-        merged.update(extra)
-    return merged
-
-
-@contextmanager
-def audit_otel_span(
-    name: str,
-    attributes: dict[str, Any] | None = None,
-) -> Any:
-    """Open an OTel span with audit context vars merged into its attributes.
-
-    Uses the shared ``vds_agent_core.observability.AgentTracer`` singleton.
-    Yields ``None`` when tracing is disabled (AgentTracer no-op mode), so
-    call sites can write ``with audit_otel_span(...) as span:`` without
-    branching on enablement.
-    """
-    from vds_agent_core.observability import AgentTracer
-
-    global _AUDIT_TRACER
-    tracer = _AUDIT_TRACER
-    if tracer is None:
-        tracer = AgentTracer(service_name="vds-audit-orchestrator")
-        _AUDIT_TRACER = tracer
-
-    merged = audit_trace_attrs(attributes)
-    with tracer.open_span(name, attributes=merged) as span:
-        yield span
-
-
-# Module-level singleton AgentTracer for the audit orchestrator. Lazy-init in
-# ``audit_otel_span`` so import order does not force OTel initialization.
-_AUDIT_TRACER: Any = None

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/mappings/__init__.py

@@ -1,58 +0,0 @@
-"""Default mapping configurations for Google Sheets templates.
-
-This module provides bundled mapping files for common Google Sheets template formats.
-Users can also provide their own mapping files via the --template-map CLI option.
-
-To use the bundled default mapping:
-    vds-cli audit --template-url <URL> --template-sheet Checklist
-
-To use a custom mapping file:
-    vds-cli audit --template-url <URL> --template-map /path/to/custom_mapping.json
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-# Directory containing bundled mapping files
-_BUNDLED_MAPPINGS_DIR = Path(__file__).parent
-
-# Default mapping file names
-DEFAULT_CHECKLIST_MAPPING_FILE = "default_checklist_mapping.json"
-
-
-def get_bundled_mapping_path(name: str) -> Path | None:
-    """Get the path to a bundled mapping file by name.
-
-    Args:
-        name: Name of the mapping file (e.g., "default_checklist_mapping.json")
-
-    Returns:
-        Path to the mapping file, or None if not found
-
-    Example:
-        >>> path = get_bundled_mapping_path("default_checklist_mapping.json")
-        >>> if path:
-        ...     mapping = load_mapping_file(path)
-    """
-    candidate = _BUNDLED_MAPPINGS_DIR / name
-    if candidate.exists():
-        return candidate
-    return None
-
-
-def list_bundled_mappings() -> list[str]:
-    """List all available bundled mapping files.
-
-    Returns:
-        List of mapping file names (without .json extension)
-
-    Example:
-        >>> for name in list_bundled_mappings():
-        ...     print(f"- {name}")
-    """
-    mappings = []
-    for path in _BUNDLED_MAPPINGS_DIR.glob("*.json"):
-        if path.name != "__init__.py":
-            mappings.append(path.stem)
-    return sorted(mappings)

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/mappings/default_checklist_mapping.json

@@ -1,18 +0,0 @@
-{
-  "_comment": "Default mapping for the public Checklist Google Sheet, including the Phase 120 backend worksheet (gid 2126622691). Source: https://docs.google.com/spreadsheets/d/13aZlARMCDaBod8FaObEK0FwzOtqKYCDEcmF1m1jpzZE/edit?gid=2126622691",
-  "rule_column": "Quy tắc",
-  "group_column": "Tiêu chí chính",
-  "check_column": "Tiêu chí con kỹ thuật (Chi tiết & Actionable)",
-  "weight_column": "Trọng số",
-  "notes_column": "Hướng dẫn chi tiết",
-  "forward_fill_columns": [
-    "Quy tắc",
-    "Tiêu chí chính"
-  ],
-  "summary_markers": [
-    "TONG CONG",
-    "TỔNG CỘNG",
-    "TOTAL"
-  ],
-  "template_name": "Checklist (Google Sheet)"
-}

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/mappings/vietnamese_checklist_mapping.json

@@ -1,38 +0,0 @@
-{
-  "_comment": "Vietnamese checklist mapping profile for Google Sheets templates. Supports the widened backend checklist format with operator guidance columns, including Phase 120 worksheet gid 2126622691.",
-  "profile_name": "vietnamese_checklist",
-  "profile_display_name": "Vietnamese Checklist (Google Sheet)",
-  "rule_column": "Quy tắc",
-  "group_column": "Tiêu chí chính",
-  "check_column": "Tiêu chí con kỹ thuật (Chi tiết & Actionable)",
-  "weight_column": "Trọng số",
-  "notes_column": "Hướng dẫn chi tiết",
-  "forward_fill_columns": [
-    "Quy tắc",
-    "Tiêu chí chính"
-  ],
-  "summary_markers": [
-    "TONG CONG",
-    "TỔNG CỘNG",
-    "TOTAL",
-    "Tổng"
-  ],
-  "template_name": "Vietnamese Checklist",
-  "language": "vi",
-  "weight_normalization": "percent_to_decimal",
-  "scoring_columns": {
-    "miniapp": "Miniapp_Điểm (1-5)",
-    "average": "Average",
-    "payment_gateway": "Cổng thanh toán Average",
-    "readiness": "Mức độ sẵn sàng",
-    "conclusion": "Kết luận"
-  },
-  "ignore_columns": [
-    "Điểm",
-    "Mức độ sẵn sàng",
-    "Kết luận",
-    "Miniapp_Điểm (1-5)",
-    "Average",
-    "Cổng thanh toán Average"
-  ]
-}