feat(spp_api_v2): add outgoing API log model, service, and menu

Wire up the spp.api.outgoing.log model with manifest registration,
ACL rules (viewer read-only, officer/manager read+write), the
OutgoingApiLogService wrapper with payload truncation and error
resilience, and an "Outgoing API Logs" menu item under API V2.

Author: jeremi

spp_api_v2/__manifest__.py

@@ -37,6 +37,7 @@
         "views/api_extension_views.xml",
         "views/api_path_views.xml",
         "views/consent_views.xml",
+        "views/api_outgoing_log_views.xml",
         "views/menu.xml",
     ],
     "assets": {},

spp_api_v2/models/__init__.py

@@ -1,5 +1,6 @@
 from . import api_audit_log
 from . import api_client
+from . import api_outgoing_log
 from . import api_client_scope
 from . import api_extension
 from . import api_filter_preset

spp_api_v2/security/ir.model.access.csv

@@ -57,3 +57,6 @@ access_spp_api_client_show_secret_wizard_admin,spp.api.client.show.secret.wizard
 access_spp_api_audit_log_viewer,spp.api.audit.log viewer,model_spp_api_audit_log,group_api_v2_viewer,1,0,0,0
 access_spp_api_audit_log_officer,spp.api.audit.log officer,model_spp_api_audit_log,group_api_v2_officer,1,0,1,0
 access_spp_api_audit_log_manager,spp.api.audit.log manager,model_spp_api_audit_log,group_api_v2_manager,1,0,1,0
+access_spp_api_outgoing_log_viewer,spp.api.outgoing.log viewer,model_spp_api_outgoing_log,group_api_v2_viewer,1,0,0,0
+access_spp_api_outgoing_log_officer,spp.api.outgoing.log officer,model_spp_api_outgoing_log,group_api_v2_officer,1,0,1,0
+access_spp_api_outgoing_log_manager,spp.api.outgoing.log manager,model_spp_api_outgoing_log,group_api_v2_manager,1,0,1,0

spp_api_v2/services/__init__.py

@@ -1,5 +1,6 @@
 from . import api_audit_service
 from . import auth_service
+from . import outgoing_api_log_service
 from . import bundle_service
 from . import consent_service
 from . import filter_service

spp_api_v2/services/outgoing_api_log_service.py

@@ -0,0 +1,135 @@
+# Part of OpenSPP. See LICENSE file for full copyright and licensing details.
+"""Service for logging outgoing API calls."""
+
+import json
+import logging
+
+import psycopg2
+
+from odoo.api import Environment
+
+_logger = logging.getLogger(__name__)
+
+
+class OutgoingApiLogService:
+    """
+    Service for logging outgoing HTTP calls to the audit log.
+
+    Wraps spp.api.outgoing.log with try/except so logging failures
+    never prevent the actual API call from succeeding.
+
+    Usage:
+        service = OutgoingApiLogService(env, "DCI Client", "crvs_main")
+        service.log_call(
+            url="https://crvs.example.org/api/registry/sync/search",
+            endpoint="/registry/sync/search",
+            http_method="POST",
+            request_summary={"header": {...}},
+            response_summary={"header": {...}},
+            response_status_code=200,
+            duration_ms=350,
+            origin_model="spp.dci.data.source",
+            origin_record_id=42,
+            status="success",
+        )
+    """
+
+    def __init__(
+        self,
+        env: Environment,
+        service_name: str,
+        service_code: str,
+        user_id: int = None,
+    ):
+        """
+        Initialize the outgoing API log service.
+
+        Args:
+            env: Odoo environment
+            service_name: Human-readable service name (e.g. "DCI Client")
+            service_code: Machine-readable service code (e.g. "crvs_main")
+            user_id: User ID to record (defaults to env.uid)
+        """
+        self.env = env
+        self.service_name = service_name
+        self.service_code = service_code
+        self.user_id = user_id or env.uid
+
+    def log_call(
+        self,
+        url: str,
+        endpoint: str = None,
+        http_method: str = "POST",
+        request_summary: dict = None,
+        response_summary: dict = None,
+        response_status_code: int = None,
+        duration_ms: int = None,
+        origin_model: str = None,
+        origin_record_id: int = None,
+        status: str = "success",
+        error_detail: str = None,
+    ):
+        """
+        Log an outgoing API call.
+
+        Returns the created record, or None if logging fails.
+        Logging failures never raise exceptions.
+        """
+        try:
+            # Truncate large payloads
+            truncated_request = self._truncate_payload(request_summary)
+            truncated_response = self._truncate_payload(response_summary)
+
+            return (
+                self.env["spp.api.outgoing.log"]
+                .sudo()
+                .log_call(
+                    url=url,
+                    endpoint=endpoint,
+                    http_method=http_method,
+                    request_summary=truncated_request,
+                    response_summary=truncated_response,
+                    response_status_code=response_status_code,
+                    user_id=self.user_id,
+                    origin_model=origin_model,
+                    origin_record_id=origin_record_id,
+                    duration_ms=duration_ms,
+                    service_name=self.service_name,
+                    service_code=self.service_code,
+                    status=status,
+                    error_detail=error_detail,
+                )
+            )
+        except (KeyError, AttributeError, TypeError) as e:
+            _logger.warning("Failed to log outgoing API call due to data error: %s", type(e).__name__)
+            return None
+        except (psycopg2.Error, ValueError, RuntimeError):
+            _logger.exception("Failed to log outgoing API call")
+            return None
+
+    def _truncate_payload(self, payload, max_length=10000):
+        """Truncate large payloads for DB storage.
+
+        Args:
+            payload: Dict payload to potentially truncate
+            max_length: Maximum JSON string length (default 10000)
+
+        Returns:
+            Original payload if within limit, or truncated version
+        """
+        if payload is None:
+            return None
+
+        try:
+            serialized = json.dumps(payload)
+        except (TypeError, ValueError):
+            return {"_truncated": True, "_error": "Could not serialize payload"}
+
+        if len(serialized) <= max_length:
+            return payload
+
+        return {
+            "_truncated": True,
+            "_original_length": len(serialized),
+            "_preview": serialized[:max_length],
+        }

spp_api_v2/tests/__init__.py

@@ -4,6 +4,8 @@
 from . import common
 from . import test_api_audit_log
 from . import test_api_audit_service
+from . import test_api_outgoing_log
+from . import test_outgoing_api_log_service
 from . import test_api_auth_enforcement
 from . import test_api_client
 from . import test_api_consent_matching

spp_api_v2/tests/test_outgoing_api_log_service.py

@@ -0,0 +1,188 @@
+# Part of OpenSPP. See LICENSE file for full copyright and licensing details.
+"""Tests for OutgoingApiLogService"""
+
+from odoo.tests.common import TransactionCase
+
+from ..services.outgoing_api_log_service import OutgoingApiLogService
+
+
+class TestOutgoingApiLogService(TransactionCase):
+    """Test OutgoingApiLogService functionality"""
+
+    def setUp(self):
+        super().setUp()
+        self.outgoing_log_model = self.env["spp.api.outgoing.log"]
+
+    def test_log_call_creates_record(self):
+        """log_call creates outgoing log record via the service"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="DCI Client",
+            service_code="crvs_main",
+        )
+
+        result = service.log_call(
+            url="https://crvs.example.org/api/registry/sync/search",
+            endpoint="/registry/sync/search",
+            http_method="POST",
+            request_summary={"header": {"action": "search"}},
+            response_summary={"header": {"status": "success"}},
+            response_status_code=200,
+            duration_ms=350,
+            origin_model="spp.dci.data.source",
+            origin_record_id=42,
+            status="success",
+        )
+
+        self.assertTrue(result)
+        self.assertEqual(result.url, "https://crvs.example.org/api/registry/sync/search")
+        self.assertEqual(result.service_name, "DCI Client")
+        self.assertEqual(result.service_code, "crvs_main")
+        self.assertEqual(result.status, "success")
+
+    def test_log_call_failure_returns_none(self):
+        """Logging failures return None and don't raise exceptions"""
+        # Create a service with a broken env to trigger a failure
+        bad_service = OutgoingApiLogService(
+            self.env,
+            service_name="Bad Service",
+            service_code="bad",
+        )
+
+        # Monkey-patch the model to raise an error
+        original_log_call = self.outgoing_log_model.__class__.log_call
+
+        def broken_log_call(self_model, **kwargs):
+            raise RuntimeError("Database error")
+
+        self.outgoing_log_model.__class__.log_call = broken_log_call
+        try:
+            result = bad_service.log_call(
+                url="https://example.org/test",
+            )
+            self.assertIsNone(result)
+        finally:
+            self.outgoing_log_model.__class__.log_call = original_log_call
+
+    def test_truncate_payload(self):
+        """_truncate_payload truncates large payloads"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="Test",
+            service_code="test",
+        )
+
+        # Small payload should pass through unchanged
+        small = {"key": "value"}
+        self.assertEqual(service._truncate_payload(small), small)
+
+        # None should return None
+        self.assertIsNone(service._truncate_payload(None))
+
+        # Large payload should be truncated
+        large = {"data": "x" * 20000}
+        result = service._truncate_payload(large, max_length=100)
+        self.assertTrue(result["_truncated"])
+        self.assertIn("_original_length", result)
+        self.assertIn("_preview", result)
+
+    def test_service_stores_user_id(self):
+        """Service records the correct user_id"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="Test",
+            service_code="test",
+            user_id=self.env.uid,
+        )
+
+        result = service.log_call(
+            url="https://example.org/test",
+        )
+
+        self.assertTrue(result)
+        self.assertEqual(result.user_id.id, self.env.uid)
+
+    def test_service_stores_service_context(self):
+        """Service stores service_name and service_code on log records"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="My Integration",
+            service_code="my_integration_v1",
+        )
+
+        result = service.log_call(
+            url="https://example.org/test",
+        )
+
+        self.assertTrue(result)
+        self.assertEqual(result.service_name, "My Integration")
+        self.assertEqual(result.service_code, "my_integration_v1")
+
+    def test_service_default_user_id(self):
+        """Service defaults to env.uid when user_id not provided"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="Test",
+            service_code="test",
+        )
+
+        self.assertEqual(service.user_id, self.env.uid)
+
+    def test_truncate_payload_non_serializable(self):
+        """_truncate_payload handles non-JSON-serializable payloads"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="Test",
+            service_code="test",
+        )
+
+        # Object that can't be serialized
+        result = service._truncate_payload({"key": object()})
+        self.assertTrue(result["_truncated"])
+        self.assertIn("_error", result)
+
+    def test_truncate_payload_exact_boundary(self):
+        """_truncate_payload passes through payload at exactly max_length"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="Test",
+            service_code="test",
+        )
+
+        # Build a payload whose JSON serialization is exactly max_length
+        import json
+
+        max_length = 50
+        # {"k": "..."} — adjust value to hit exact length
+        base = json.dumps({"k": ""})  # '{"k": ""}' = 10 chars
+        filler = "x" * (max_length - len(base))
+        payload = {"k": filler}
+        serialized = json.dumps(payload)
+        self.assertEqual(len(serialized), max_length)
+
+        result = service._truncate_payload(payload, max_length=max_length)
+        # Should pass through unchanged (equal to limit)
+        self.assertEqual(result, payload)
+        self.assertNotIn("_truncated", result)
+
+    def test_truncate_payload_one_over_boundary(self):
+        """_truncate_payload truncates payload one byte over max_length"""
+        service = OutgoingApiLogService(
+            self.env,
+            service_name="Test",
+            service_code="test",
+        )
+
+        import json
+
+        max_length = 50
+        base = json.dumps({"k": ""})
+        filler = "x" * (max_length - len(base) + 1)
+        payload = {"k": filler}
+        serialized = json.dumps(payload)
+        self.assertEqual(len(serialized), max_length + 1)
+
+        result = service._truncate_payload(payload, max_length=max_length)
+        self.assertTrue(result["_truncated"])
+        self.assertEqual(result["_original_length"], max_length + 1)
+        self.assertEqual(len(result["_preview"]), max_length)