imbi-api 2.35.0__tar.gz → 2.36.0__tar.gz

{imbi_api-2.35.0 → imbi_api-2.36.0}/.gitignore

@@ -20,3 +20,11 @@ site/
 # moon
 .moon/cache
 .moon/docker
+
+# design-sync
+.design-sync/sb-reference/
+.design-sync/learnings/
+.design-sync/.cache/
+.design-sync/node_modules
+.ds-sync/
+ds-bundle/

{imbi_api-2.35.0 → imbi_api-2.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: imbi-api
-Version: 2.35.0
+Version: 2.36.0
 Summary: Imbi is a DevOps Service Management Platform designed to provide an efficient way to manage a large environment that contains many services and applications.
 Author-email: Alex Campbell <alexc@aweber.com>, Dave Shawley <daves@aweber.com>, "Gavin M. Roy" <gavinr@aweber.com>
 License-Expression: BSD-3-Clause
@@ -19,7 +19,7 @@ Requires-Dist: cyclonedx-python-lib<12,>=11.7
 Requires-Dist: fastapi
 Requires-Dist: filetype
 Requires-Dist: httpx<1,>=0.28.1
-Requires-Dist: imbi-common[databases,llm,sentry,server]==2.35.0
+Requires-Dist: imbi-common[databases,llm,sentry,server]==2.36.0
 Requires-Dist: jinja2
 Requires-Dist: jsonpatch>=1.33
 Requires-Dist: mcp>=1.26.0

{imbi_api-2.35.0 → imbi_api-2.36.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "imbi-api"
-version = "2.35.0"
+version = "2.36.0"
 description = "Imbi is a DevOps Service Management Platform designed to provide an efficient way to manage a large environment that contains many services and applications."
 readme = "README.md"
 requires-python = ">=3.14"
@@ -28,7 +28,7 @@ dependencies = [
   "fastapi",
   "filetype",
   "httpx>=0.28.1,<1",
-  "imbi-common[databases,llm,sentry,server]==2.35.0",
+  "imbi-common[databases,llm,sentry,server]==2.36.0",
   "jinja2",
   "jsonpatch>=1.33",
   "mcp>=1.26.0",

{imbi_api-2.35.0 → imbi_api-2.36.0}/src/imbi/api/email/client.py

@@ -140,11 +140,16 @@ class EmailClient:
                     await asyncio.sleep(delay)
                     delay *= self._settings.retry_backoff_factor
 
-        # All retries exhausted
+        # All retries exhausted. The audit keeps the error type and SMTP
+        # code only: exception text such as SMTPRecipientsRefused carries
+        # the recipient address, and the audit must not store it.
         error_msg = (
             f'SMTP error after {self._settings.max_retries + 1} attempts: '
-            f'{last_error}'
+            f'{type(last_error).__name__}'
         )
+        smtp_code = getattr(last_error, 'smtp_code', None)
+        if smtp_code is not None:
+            error_msg += f' ({smtp_code})'
         return self._create_audit(message, 'failed', error_msg)
 
     async def _send_smtp(self, message: models.EmailMessage) -> None:

{imbi_api-2.35.0 → imbi_api-2.36.0}/src/imbi/api/endpoints/dashboard.py

@@ -89,6 +89,24 @@ class DashboardMetrics(pydantic.BaseModel):
     releases_by_environment: list[EnvironmentCount]
 
 
+class IggyTopic(iggy.TopicStatus):
+    """One Iggy topic and the sink group that consumes it."""
+
+    # @TODO: Fill `stored_offset` and `lag` when Iggy can read a group
+    # offset over HTTP (apache/iggy#4279) or the Python SDK exposes the
+    # offset read (apache/iggy#3997). `lag` is `current_offset` minus
+    # `stored_offset`. Until then they are always `None`.
+    stored_offset: int | None = None
+    lag: int | None = None
+
+
+class IggyTopics(pydantic.BaseModel):
+    """Per-topic Iggy state for the admin dashboard."""
+
+    checked_at: datetime.datetime
+    topics: list[IggyTopic]
+
+
 def _ms(start: float) -> float:
     """Milliseconds elapsed since *start* (``time.perf_counter()``)."""
     return round((time.perf_counter() - start) * 1000, 1)
@@ -306,6 +324,36 @@ async def get_dashboard_status(
     )
 
 
+# Reads one topic and one group per topic, all in flight together, so
+# it gets more time than a single health check.
+_IGGY_TOPICS_TIMEOUT = 5.0
+
+
+@dashboard_router.get('/iggy', response_model=IggyTopics)
+async def get_dashboard_iggy(
+    auth: typing.Annotated[
+        permissions.AuthContext,
+        fastapi.Depends(
+            permissions.require_permission('admin:dashboard:read')
+        ),
+    ],
+) -> IggyTopics:
+    """Return each Iggy topic with its sink group's members."""
+    try:
+        topics = await asyncio.wait_for(
+            iggy.topic_status(), _IGGY_TOPICS_TIMEOUT
+        )
+    except Exception as err:
+        LOGGER.warning('Iggy topic status failed: %s', err)
+        raise fastapi.HTTPException(
+            status_code=503, detail='Iggy topic status is unavailable'
+        ) from err
+    return IggyTopics(
+        checked_at=datetime.datetime.now(datetime.UTC),
+        topics=[IggyTopic(**topic.model_dump()) for topic in topics],
+    )
+
+
 _METRICS_WINDOW_DAYS = 7
 
 

{imbi_api-2.35.0 → imbi_api-2.36.0}/src/imbi/api/maintenance/operations.py

@@ -830,12 +830,12 @@ async def execute_opslog_backfill(
         )
 
     if pending:
-        rows: list[dict[str, typing.Any]] = []
+        entries: list[dict[str, typing.Any]] = []
         for entry in pending:
             dumped = entry.model_dump(by_alias=True, mode='python')
             dumped['is_deleted'] = 1 if entry.is_deleted else 0
-            rows.append(dumped)
-        await iggy.publish_rows('operations_log', 'maintenance', rows)
+            entries.append(dumped)
+        await iggy.publish_rows('operations_log', 'maintenance', entries)
     if repairs:
         # A separate publish: the repaired rows come off ``SELECT *``.
         LOGGER.debug(

imbi_api-2.36.0/tests/email/test_audit_clickhouse.py

@@ -0,0 +1,101 @@
+"""Email audit rows, written through the sink path to a live ClickHouse.
+
+``email_audit`` was in ``imbi.common.iggy.TOPICS`` with no table behind it,
+so every audit was published and then could never be inserted. Before the
+Iggy move the direct insert failed the same way and the error was logged
+and swallowed. Every other email test mocks ClickHouse, which is how that
+went unnoticed. These write a real audit the way the sink does and read it
+back.
+"""
+
+import datetime
+import hashlib
+import unittest
+import uuid
+
+from apps.api.tests import support
+from imbi.api import email
+from imbi.api.email import models
+from imbi.common import clickhouse
+from imbi.common.clickhouse import client
+
+
+class EmailAuditClickhouseTestCase(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self) -> None:
+        # ``Clickhouse`` is a process-wide singleton bound to the loop that
+        # opened it, and each test method gets its own loop, so take a
+        # private instance and hand the previous one back afterwards. See
+        # test_document_reads_sql for the failure this avoids.
+        self._previous = client.Clickhouse._instance
+        client.Clickhouse._instance = None
+        self.addAsyncCleanup(self._restore_singleton)
+        await clickhouse.initialize()
+        await clickhouse.setup_schema()
+
+    async def _restore_singleton(self) -> None:
+        await clickhouse.aclose()
+        client.Clickhouse._instance = self._previous
+
+    async def _read_back(self, entity_id: str) -> dict[str, object]:
+        rows = await clickhouse.query(
+            'SELECT * FROM email_audit'
+            ' WHERE related_entity_id = {entity_id:String}',
+            {'entity_id': entity_id},
+        )
+        self.assertEqual(1, len(rows))
+        return rows[0]
+
+    async def test_a_sent_email_is_audited_without_its_address(self) -> None:
+        entity_id = str(uuid.uuid4())
+        audit = models.EmailAudit(
+            to_email='Someone@Example.com',
+            template_name='password_reset',
+            subject='Reset your password',
+            status='sent',
+            sent_at=datetime.datetime.now(datetime.UTC),
+            user_id='user-1',
+            related_entity_type='password_reset_token',
+            related_entity_id=entity_id,
+        )
+        with support.sink_to_clickhouse():
+            await email._save_audit(audit)
+
+        row = await self._read_back(entity_id)
+        self.assertEqual('password_reset', row['template_name'])
+        self.assertEqual('sent', row['status'])
+        self.assertEqual(
+            hashlib.sha256(b'someone@example.com').hexdigest(),
+            row['to_email_hash'],
+        )
+        # `EmailStr` lowercases the domain but keeps the local part's case.
+        self.assertEqual('example.com', row['to_email_domain'])
+        self.assertNotIn('to_email', row)
+        for address in (
+            'Someone@Example.com',
+            'Someone@example.com',
+            'someone@example.com',
+        ):
+            self.assertNotIn(address, row.values())
+
+    async def test_unset_optional_fields_land_as_empty_strings(self) -> None:
+        # `EmailAudit` sends null for its optional fields and the columns are
+        # not Nullable, so this pins the server's null-as-default behaviour
+        # the table depends on.
+        entity_id = str(uuid.uuid4())
+        audit = models.EmailAudit(
+            to_email='someone@example.com',
+            template_name='password_reset',
+            subject='Reset your password',
+            status='failed',
+            error_message=None,
+            sent_at=datetime.datetime.now(datetime.UTC),
+            related_entity_id=entity_id,
+        )
+        with support.sink_to_clickhouse():
+            await email._save_audit(audit)
+
+        row = await self._read_back(entity_id)
+        self.assertEqual('failed', row['status'])
+        self.assertEqual('', row['error_message'])
+        self.assertEqual('', row['user_id'])
+        self.assertEqual('', row['related_entity_type'])

{imbi_api-2.35.0 → imbi_api-2.36.0}/tests/email/test_client.py

@@ -336,9 +336,39 @@ class EmailClientTestCase(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(audit.status, 'failed')
         assert audit.error_message is not None
         self.assertIn('after 3 attempts', audit.error_message)
-        self.assertIn('Persistent error', audit.error_message)
+        self.assertIn('SMTPException', audit.error_message)
+        self.assertNotIn('Persistent error', audit.error_message)
         self.assertEqual(self.mock_smtp.send_message.call_count, 3)
 
+    async def test_failed_audit_omits_refused_recipient(self) -> None:
+        """Test the failure message does not carry the recipient address."""
+        self.mock_settings.max_retries = 0
+
+        email_client = client.EmailClient()
+        await email_client.initialize()
+
+        message = models.EmailMessage(
+            to_email='user@example.com',
+            subject='Test',
+            html_body='<p>Test</p>',
+            text_body='Test',
+            template_name='test',
+            context={},
+        )
+
+        self.mock_smtp.send_message.side_effect = (
+            smtplib.SMTPRecipientsRefused(
+                {'user@example.com': (550, b'User unknown')}
+            )
+        )
+
+        audit = await email_client.send_email(message)
+
+        self.assertEqual(audit.status, 'failed')
+        assert audit.error_message is not None
+        self.assertIn('SMTPRecipientsRefused', audit.error_message)
+        self.assertNotIn('user@example.com', audit.error_message)
+
     async def test_retry_exponential_backoff(self) -> None:
         """Test exponential backoff delays."""
         self.mock_settings.max_retries = 3

{imbi_api-2.35.0 → imbi_api-2.36.0}/tests/endpoints/test_dashboard.py

@@ -10,7 +10,7 @@ from apps.api.tests import support
 from imbi.api import models, settings
 from imbi.api.auth import password, permissions
 from imbi.api.endpoints import dashboard
-from imbi.common import graph
+from imbi.common import graph, iggy
 
 
 def _ok_status_handler(request: httpx.Request) -> httpx.Response:
@@ -239,6 +239,75 @@ class DashboardStatusEndpointTestCase(support.SharedAppTestCase):
         self.assertEqual(403, response.status_code)
 
 
+class DashboardIggyEndpointTestCase(support.SharedAppTestCase):
+    """Test cases for GET /admin/dashboard/iggy."""
+
+    def setUp(self) -> None:
+        self.admin_context = permissions.AuthContext(
+            user=models.User(
+                email='admin@example.com',
+                display_name='Admin User',
+                is_active=True,
+                is_admin=True,
+                password_hash=password.hash_password('testpassword123'),
+                created_at=datetime.datetime.now(datetime.UTC),
+            ),
+            session_id='test-session',
+            auth_method='jwt',
+            permissions=set(),
+        )
+
+        async def mock_get_current_user():
+            return self.admin_context
+
+        self.test_app.dependency_overrides[permissions.get_current_user] = (
+            mock_get_current_user
+        )
+        self.client = testclient.TestClient(self.test_app)
+        self.topic_status = self.enterContext(
+            mock.patch.object(
+                dashboard.iggy,
+                'topic_status',
+                new=mock.AsyncMock(
+                    return_value=[
+                        iggy.TopicStatus(
+                            stream='operations_log',
+                            topic='deployments',
+                            messages=223,
+                            current_offset=222,
+                            size_bytes=4096,
+                            consumer_group='operations_log',
+                            members=2,
+                            members_owning=1,
+                        )
+                    ]
+                ),
+            )
+        )
+
+    def test_returns_each_topic(self) -> None:
+        response = self.client.get('/admin/dashboard/iggy')
+        self.assertEqual(200, response.status_code)
+        [topic] = response.json()['topics']
+        self.assertEqual('operations_log', topic['stream'])
+        self.assertEqual(222, topic['current_offset'])
+        self.assertEqual(2, topic['members'])
+        self.assertEqual(1, topic['members_owning'])
+        # Iggy cannot return a group offset over HTTP yet.
+        self.assertIsNone(topic['stored_offset'])
+        self.assertIsNone(topic['lag'])
+
+    def test_iggy_failure_is_503(self) -> None:
+        self.topic_status.side_effect = RuntimeError('disconnected')
+        response = self.client.get('/admin/dashboard/iggy')
+        self.assertEqual(503, response.status_code)
+
+    def test_requires_permission(self) -> None:
+        self.admin_context.user.is_admin = False
+        response = self.client.get('/admin/dashboard/iggy')
+        self.assertEqual(403, response.status_code)
+
+
 class DashboardMetricsEndpointTestCase(support.SharedAppTestCase):
     """Test cases for GET /admin/dashboard/metrics."""
 

{imbi_api-2.35.0 → imbi_api-2.36.0}/tests/endpoints/test_iggy_connectors.py

@@ -317,8 +317,10 @@ class WriteRoutesTestCase(_EndpointTestCase):
 class OpenAPITestCase(_EndpointTestCase):
     def test_routes_are_not_published(self) -> None:
         paths = self.client.get('/openapi.json').json()['paths']
+        # Only the connector configuration is private; other Iggy
+        # routes (e.g. /admin/dashboard/iggy) are public UI endpoints.
         self.assertFalse(
-            [path for path in paths if 'iggy' in path],
+            [path for path in paths if '/iggy/connectors' in path],
             'the connector configuration must stay out of the schema',
         )
 

{imbi_api-2.35.0 → imbi_api-2.36.0}/tests/endpoints/test_project_deployments.py

@@ -767,11 +767,14 @@ class ProjectDeploymentsTestCase(support.SharedAppTestCase):
                 pattern=r'^\d{4}([.-])\d{1,2}\1\d{1,2}(?:[.-]\w+)?$',
             )
         ]
+        # Same-day rebuild: the calver suggestion depends on today's date,
+        # so derive the tags from it rather than hardcoding one.
+        stamp = datetime.datetime.now(datetime.UTC).date().strftime('%Y.%m.%d')
         self.mock_anthropic.complete_json = mock.AsyncMock(
             return_value=CompletionResult(
                 data=DraftReleaseNotes(
                     bump='patch',
-                    version='2026.09.17-1',
+                    version=f'{stamp}-1',
                     reasoning='same-day rebuild',
                     notes_markdown='## Fixed',
                 ),
@@ -783,17 +786,17 @@ class ProjectDeploymentsTestCase(support.SharedAppTestCase):
                 '/organizations/myorg/projects/proj1/deployments/'
                 'draft-release-notes',
                 json={
-                    'base_sha': '2026.09.17-0',
+                    'base_sha': f'{stamp}-0',
                     'head_sha': 'bbb',
-                    'last_tag': '2026.09.17-0',
+                    'last_tag': f'{stamp}-0',
                 },
             )
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json()['version'], '2026.09.17-1')
+        self.assertEqual(response.json()['version'], f'{stamp}-1')
         call = self.mock_anthropic.complete_json.call_args
         prompt = call.args[0] if call.args else call.kwargs.get('prompt', '')
         self.assertIn('Allowed tag formats: Calendar versioning', prompt)
-        self.assertIn('Suggested next version: 2026.09.17-1', prompt)
+        self.assertIn(f'Suggested next version: {stamp}-1', prompt)
 
     def test_draft_release_notes_rebumps_to_the_policy(self) -> None:
         """A semver answer under a calver-only policy becomes a date."""