servicekit 0.8.2__tar.gz → 0.9.0__tar.gz

{servicekit-0.8.2 → servicekit-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: servicekit
-Version: 0.8.2
+Version: 0.9.0
 Summary: Async SQLAlchemy framework with FastAPI integration - reusable foundation for building data services
 Keywords: fastapi,sqlalchemy,async,database,rest-api,crud,framework
 Author: Morten Hansen

{servicekit-0.8.2 → servicekit-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "servicekit"
-version = "0.8.2"
+version = "0.9.0"
 description = "Async SQLAlchemy framework with FastAPI integration - reusable foundation for building data services"
 readme = "README.md"
 authors = [{ name = "Morten Hansen", email = "morten@winterop.com" }]

{servicekit-0.8.2 → servicekit-0.9.0}/src/servicekit/api/registration.py

@@ -6,7 +6,7 @@ import socket
 from typing import Any
 
 import httpx
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from servicekit.logging import get_logger
 
@@ -19,6 +19,26 @@ _ping_url: str | None = None
 _service_key: str | None = None
 
 
+class RegistrationConfig(BaseModel):
+    """Parameters for service registration, used for re-registration in keepalive."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    orchestrator_url: str | None = None
+    host: str | None = None
+    port: int | None = None
+    info: BaseModel
+    orchestrator_url_env: str = "SERVICEKIT_ORCHESTRATOR_URL"
+    host_env: str = "SERVICEKIT_HOST"
+    port_env: str = "SERVICEKIT_PORT"
+    max_retries: int = 5
+    retry_delay: float = 2.0
+    fail_on_error: bool = False
+    timeout: float = 10.0
+    service_key: str | None = None
+    service_key_env: str = "SERVICEKIT_REGISTRATION_KEY"
+
+
 def _resolve_service_key(service_key: str | None, service_key_env: str) -> str | None:
     """Resolve service key from parameter or environment variable."""
     if service_key:
@@ -218,7 +238,14 @@ async def register_service(
     return None
 
 
-async def _keepalive_loop(ping_url: str, interval: float, timeout: float, service_key: str | None) -> None:
+async def _keepalive_loop(
+    ping_url: str,
+    interval: float,
+    timeout: float,
+    service_key: str | None,
+    registration_config: RegistrationConfig | None = None,
+    re_register_grace_period: float = 30.0,
+) -> None:
     """Background task to periodically ping the orchestrator."""
     logger.info("keepalive.started", ping_url=ping_url, interval_seconds=interval)
 
@@ -247,6 +274,54 @@ async def _keepalive_loop(ping_url: str, interval: float, timeout: float, servic
             logger.info("keepalive.cancelled", service_id=_service_id)
             raise
 
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404 and registration_config is not None:
+                logger.warning(
+                    "keepalive.service_not_found",
+                    service_id=_service_id,
+                    ping_url=ping_url,
+                    grace_period=re_register_grace_period,
+                )
+
+                # Grace period to avoid thundering herd during orchestrator flap
+                await asyncio.sleep(re_register_grace_period)
+
+                # Attempt re-registration with original parameters
+                try:
+                    result = await register_service(**registration_config.model_dump())
+                    if result and result.get("ping_url"):
+                        ping_url = result["ping_url"]
+                        # Rebuild headers in case service_key changed
+                        headers = {}
+                        if _service_key:
+                            headers["X-Service-Key"] = _service_key
+                        logger.info(
+                            "keepalive.re_registered",
+                            service_id=_service_id,
+                            new_ping_url=ping_url,
+                        )
+                    else:
+                        logger.warning(
+                            "keepalive.re_registration_failed",
+                            service_id=_service_id,
+                            reason="register_service returned None",
+                        )
+                except Exception as re_reg_error:
+                    logger.warning(
+                        "keepalive.re_registration_error",
+                        service_id=_service_id,
+                        error=str(re_reg_error),
+                        error_type=type(re_reg_error).__name__,
+                    )
+            else:
+                logger.warning(
+                    "keepalive.ping_failed",
+                    service_id=_service_id,
+                    ping_url=ping_url,
+                    error=str(e),
+                    error_type=type(e).__name__,
+                )
+
         except Exception as e:
             logger.warning(
                 "keepalive.ping_failed",
@@ -264,6 +339,8 @@ async def start_keepalive(
     timeout: float = 10.0,
     service_key: str | None = None,
     service_key_env: str = "SERVICEKIT_REGISTRATION_KEY",
+    registration_config: RegistrationConfig | None = None,
+    re_register_grace_period: float = 30.0,
 ) -> None:
     """Start background keepalive task to ping orchestrator."""
     global _keepalive_task
@@ -275,7 +352,16 @@ async def start_keepalive(
     # Resolve service key (use global from registration if not provided)
     resolved_service_key = _resolve_service_key(service_key, service_key_env) or _service_key
 
-    _keepalive_task = asyncio.create_task(_keepalive_loop(ping_url, interval, timeout, resolved_service_key))
+    _keepalive_task = asyncio.create_task(
+        _keepalive_loop(
+            ping_url,
+            interval,
+            timeout,
+            resolved_service_key,
+            registration_config=registration_config,
+            re_register_grace_period=re_register_grace_period,
+        )
+    )
     logger.info("keepalive.task_started", ping_url=ping_url, interval_seconds=interval)
 
 

{servicekit-0.8.2 → servicekit-0.9.0}/src/servicekit/api/service_builder.py

@@ -95,6 +95,7 @@ class _RegistrationOptions:
     auto_deregister: bool
     service_key: str | None
     service_key_env: str
+    re_register_grace_period: float
 
 
 class ServiceInfo(BaseModel):
@@ -330,6 +331,7 @@ class BaseServiceBuilder:
         auto_deregister: bool = True,
         service_key: str | None = None,
         service_key_env: str = "SERVICEKIT_REGISTRATION_KEY",
+        re_register_grace_period: float = 30.0,
     ) -> Self:
         """Enable service registration with orchestrator for service discovery."""
         self._registration_options = _RegistrationOptions(
@@ -348,6 +350,7 @@ class BaseServiceBuilder:
             auto_deregister=auto_deregister,
             service_key=service_key,
             service_key_env=service_key_env,
+            re_register_grace_period=re_register_grace_period,
         )
         return self
 
@@ -685,12 +688,31 @@ class BaseServiceBuilder:
                 if registration_info and registration_options.enable_keepalive:
                     ping_url = registration_info.get("ping_url")
                     if ping_url:
+                        from .registration import RegistrationConfig
+
+                        registration_config = RegistrationConfig(
+                            orchestrator_url=registration_options.orchestrator_url,
+                            host=registration_options.host,
+                            port=registration_options.port,
+                            info=info,
+                            orchestrator_url_env=registration_options.orchestrator_url_env,
+                            host_env=registration_options.host_env,
+                            port_env=registration_options.port_env,
+                            max_retries=registration_options.max_retries,
+                            retry_delay=registration_options.retry_delay,
+                            fail_on_error=False,
+                            timeout=registration_options.timeout,
+                            service_key=registration_options.service_key,
+                            service_key_env=registration_options.service_key_env,
+                        )
                         await start_keepalive(
                             ping_url=ping_url,
                             interval=registration_options.keepalive_interval,
                             timeout=registration_options.timeout,
                             service_key=registration_options.service_key,
                             service_key_env=registration_options.service_key_env,
+                            registration_config=registration_config,
+                            re_register_grace_period=registration_options.re_register_grace_period,
                         )
 
             try: