sovereign 1.0.0b103__tar.gz → 1.0.0b106__tar.gz

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sovereign
-Version: 1.0.0b103
+Version: 1.0.0b106
 Summary: Envoy Proxy control-plane written in Python
 Home-page: https://pypi.org/project/sovereign/
 License: Apache-2.0

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sovereign"
-version = "1.0.0b103"
+version = "1.0.0b106"
 description = "Envoy Proxy control-plane written in Python"
 license = "Apache-2.0"
 packages = [

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/src/sovereign/schemas.py

@@ -6,7 +6,6 @@ from pathlib import Path
 from enum import Enum
 from os import getenv
 from types import ModuleType
-from collections import defaultdict
 from dataclasses import dataclass
 from functools import cached_property
 from typing import Any, Dict, List, Mapping, Optional, Self, Tuple, Union, Callable
@@ -716,6 +715,8 @@ class ContextConfiguration(BaseSettings):
 
 class SourcesConfiguration(BaseSettings):
     refresh_rate: int = Field(30, alias="SOVEREIGN_SOURCES_REFRESH_RATE")
+    max_retries: int = Field(3, alias="SOVEREIGN_SOURCES_MAX_RETRIES")
+    retry_delay: int = Field(1, alias="SOVEREIGN_SOURCES_RETRY_DELAY")
     cache_strategy: Optional[Any] = None
     model_config = SettingsConfigDict(
         env_file=".env",
@@ -765,6 +766,20 @@ class TracingConfig(BaseSettings):
         return values
 
 
+class SupervisordConfig(BaseSettings):
+    nodaemon: bool = Field(True, alias="SOVEREIGN_SUPERVISORD_NODAEMON")
+    loglevel: str = Field("error", alias="SOVEREIGN_SUPERVISORD_LOGLEVEL")
+    pidfile: str = Field("/tmp/supervisord.pid", alias="SOVEREIGN_SUPERVISORD_PIDFILE")
+    logfile: str = Field("/tmp/supervisord.log", alias="SOVEREIGN_SUPERVISORD_LOGFILE")
+    directory: str = Field("%(here)s", alias="SOVEREIGN_SUPERVISORD_DIRECTORY")
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        extra="ignore",
+        env_file_encoding="utf-8",
+        populate_by_name=True,
+    )
+
+
 class LegacyConfig(BaseSettings):
     regions: Optional[List[str]] = None
     eds_priority_matrix: Optional[Dict[str, Dict[str, int]]] = None
@@ -856,6 +871,9 @@ class SovereignConfigv2(BaseSettings):
     tracing: Optional[TracingConfig] = Field(default_factory=TracingConfig)
     debug: bool = Field(False, alias="SOVEREIGN_DEBUG")
 
+    # Supervisord settings
+    supervisord: SupervisordConfig = SupervisordConfig()
+
     # Deprecated in 0.30
     sources: Optional[List[ConfiguredSource]] = Field(None, deprecated=True)
     source_config: SourcesConfiguration = Field(

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/src/sovereign/server.py

@@ -8,10 +8,11 @@ import uvicorn
 from sovereign import application_logger as log
 from sovereign.app import app
 from sovereign.worker import worker as worker_app
-from sovereign.schemas import SovereignAsgiConfig
+from sovereign.schemas import SovereignAsgiConfig, SupervisordConfig
 
 
 asgi_config = SovereignAsgiConfig()
+supervisord_config = SupervisordConfig()
 
 
 def web() -> None:
@@ -59,8 +60,11 @@ def write_supervisor_conf() -> Path:
 
     conf = configparser.RawConfigParser()
     conf["supervisord"] = supervisord = {
-        "nodaemon": "true",
-        "loglevel": "error",
+        "nodaemon": str(supervisord_config.nodaemon).lower(),
+        "loglevel": supervisord_config.loglevel,
+        "pidfile": supervisord_config.pidfile,
+        "logfile": supervisord_config.logfile,
+        "directory": supervisord_config.directory,
     }
 
     conf["fcgi-program:web"] = web = {

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/src/sovereign/sources/poller.py

@@ -35,81 +35,58 @@ GMods = Dict[str, Type[GlobalModifier]]
 
 
 def _deep_diff(old, new, path="") -> list[dict[str, Any]]:
-    changes = []
-    
+    changes: list[dict[str, Any]] = []
+
     # handle add/remove
     if (old, new) == (None, None):
         return changes
     elif old is None:
-        changes.append({
-            "op": "add",
-            "path": path,
-            "value": new
-        })
+        changes.append({"op": "add", "path": path, "value": new})
         return changes
     elif new is None:
-        changes.append({
-            "op": "remove", 
-            "path": path,
-            "old_value": old
-        })
+        changes.append({"op": "remove", "path": path, "old_value": old})
         return changes
-    
+
     # handle completely different types
     if type(old) is not type(new):
-        changes.append({
-            "op": "change",
-            "path": path,
-            "old_value": old,
-            "new_value": new
-        })
+        changes.append(
+            {"op": "change", "path": path, "old_value": old, "new_value": new}
+        )
         return changes
-    
+
     # handle fields recursively
     if isinstance(old, dict) and isinstance(new, dict):
         all_keys = set(old.keys()) | set(new.keys())
-        
+
         for key in sorted(all_keys):
             old_val = old.get(key)
             new_val = new.get(key)
-            
+
             current_path = f"{path}.{key}" if path else key
-            
+
             if key not in old:
-                changes.append({
-                    "op": "add",
-                    "path": current_path,
-                    "value": new_val
-                })
+                changes.append({"op": "add", "path": current_path, "value": new_val})
             elif key not in new:
-                changes.append({
-                    "op": "remove",
-                    "path": current_path,
-                    "old_value": old_val
-                })
+                changes.append(
+                    {"op": "remove", "path": current_path, "old_value": old_val}
+                )
             elif old_val != new_val:
                 nested_changes = _deep_diff(old_val, new_val, current_path)
                 changes.extend(nested_changes)
-    
+
     # handle items recursively
     elif isinstance(old, list) and isinstance(new, list):
         max_len = max(len(old), len(new))
-        
+
         for i in range(max_len):
             current_path = f"{path}[{i}]" if path else f"[{i}]"
-            
+
             if i >= len(old):
-                changes.append({
-                    "op": "add",
-                    "path": current_path,
-                    "value": new[i]
-                })
+                changes.append({"op": "add", "path": current_path, "value": new[i]})
             elif i >= len(new):
-                changes.append({
-                    "op": "remove",
-                    "path": current_path,
-                    "old_value": old[i]
-                })
+                changes.append(
+                    {"op": "remove", "path": current_path, "old_value": old[i]}
+                )
             elif old[i] != new[i]:
                 nested_changes = _deep_diff(old[i], new[i], current_path)
                 changes.extend(nested_changes)
@@ -117,13 +94,10 @@ def _deep_diff(old, new, path="") -> list[dict[str, Any]]:
     # handle primitives
     else:
         if old != new:
-            changes.append({
-                "op": "change",
-                "path": path,
-                "old_value": old,
-                "new_value": new
-            })
-    
+            changes.append(
+                {"op": "change", "path": path, "old_value": old, "new_value": new}
+            )
+
     return changes
 
 
@@ -136,17 +110,9 @@ def per_field_diff(old, new) -> list[dict[str, Any]]:
         new_inst = new[i] if i < len(new) else None
 
         if old_inst is None:
-            changes.append({
-                "op": "add",
-                "path": f"[{i}]",
-                "value": new_inst
-            })
+            changes.append({"op": "add", "path": f"[{i}]", "value": new_inst})
         elif new_inst is None:
-            changes.append({
-                "op": "remove",
-                "path": f"[{i}]",
-                "old_value": old_inst
-            })
+            changes.append({"op": "remove", "path": f"[{i}]", "old_value": old_inst})
         elif old_inst != new_inst:
             # Use the deep diff with index prefix
             field_changes = _deep_diff(old_inst, new_inst, f"[{i}]")
@@ -156,7 +122,7 @@ def per_field_diff(old, new) -> list[dict[str, Any]]:
 
 
 def _gen_uuid(diff_summary: dict[str, Any]) -> str:
-    blob = json.dumps(diff_summary, sort_keys=True, separators=('', ''))
+    blob = json.dumps(diff_summary, sort_keys=True, separators=("", ""))
     return str(uuid.uuid5(uuid.NAMESPACE_DNS, blob))
 
 
@@ -168,14 +134,11 @@ def source_diff_summary(prev, curr) -> dict[str, Any]:
                 scope: {"added": len(instances)}
                 for scope, instances in curr.scopes.items()
                 if instances
-            }
+            },
         }
     else:
-        summary = {
-            "type": "update",
-            "scopes": {}
-        }
-        
+        summary = {"type": "update", "scopes": {}}
+
         all_scopes = set(prev.scopes.keys()) | set(curr.scopes.keys())
 
         for scope in sorted(all_scopes):
@@ -185,7 +148,7 @@ def source_diff_summary(prev, curr) -> dict[str, Any]:
             n_old = len(old)
             n_new = len(new)
 
-            scope_changes = {}
+            scope_changes: dict[str, Any] = {}
 
             if n_old == 0 and n_new > 0:
                 scope_changes["added"] = n_new
@@ -198,11 +161,11 @@ def source_diff_summary(prev, curr) -> dict[str, Any]:
                     scope_changes["count_change"] = n_new - n_old
 
             if scope_changes:
-                summary["scopes"][scope] = scope_changes
+                summary["scopes"][scope] = scope_changes  # type: ignore
 
         if not summary["scopes"]:
             summary = {"type": "no_changes"}
-    
+
     summary["uuid"] = _gen_uuid(summary)
     return summary
 
@@ -239,13 +202,17 @@ class SourcePoller:
         self.global_modifiers: GMods = dict()
 
         # initially set data and modify
-        self.source_data: SourceData
+        self.source_data: SourceData = SourceData()
+        self.source_data_modified: SourceData = SourceData()
         self.last_updated = datetime.now()
         self.instance_count = 0
 
         self.cache: dict[str, dict[str, list[dict[str, Any]]]] = {}
         self.registry: set[Any] = set()
 
+        # Retry state
+        self.retry_count = 0
+
     @property
     def data_is_stale(self) -> bool:
         return self.last_updated < datetime.now() - timedelta(minutes=2)
@@ -328,6 +295,10 @@ class SourcePoller:
 
     def refresh(self) -> bool:
         self.stats.increment("sources.attempt")
+
+        # Get retry config from global source config
+        max_retries = config.source_config.max_retries
+
         try:
             new = SourceData()
             for source in self.sources:
@@ -336,15 +307,25 @@ class SourcePoller:
                     new.scopes[scope] = []
                 new.scopes[scope].extend(source.get())
         except Exception as e:
+            self.retry_count += 1
             self.logger.error(
-                event="Error while refreshing sources",
+                event=f"Error while refreshing sources (attempt {self.retry_count}/{max_retries})",
                 traceback=[line for line in traceback.format_exc().split("\n")],
                 error=e.__class__.__name__,
                 detail=getattr(e, "detail", "-"),
+                retry_count=self.retry_count,
             )
             self.stats.increment("sources.error")
+
+            if self.retry_count >= max_retries:
+                # Reset retry count for next cycle
+                self.retry_count = 0
+                self.stats.increment("sources.error.final")
             return False
 
+        # Success - reset retry count
+        self.retry_count = 0
+
         # Is the new data the same as what we currently have
         if new == getattr(self, "source_data", None):
             self.stats.increment("sources.unchanged")
@@ -513,5 +494,17 @@ class SourcePoller:
         while True:
             try:
                 self.poll()
-            finally:
+
+                # If we have retry count, use exponential backoff for next attempt
+                if self.retry_count > 0:
+                    retry_delay = config.source_config.retry_delay
+                    delay = min(
+                        retry_delay * (2 ** (self.retry_count - 1)),
+                        self.source_refresh_rate,  # Cap at normal refresh rate
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    await asyncio.sleep(self.source_refresh_rate)
+            except Exception as e:
+                self.logger.error(f"Unexpected error in poll loop: {e}")
                 await asyncio.sleep(self.source_refresh_rate)

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/src/sovereign/statistics.py

@@ -53,10 +53,12 @@ def configure_statsd() -> StatsDProxy:
         from datadog import DogStatsd
 
         class CustomStatsd(DogStatsd):  # type: ignore
-            def _report(self, metric, metric_type, value, tags, sample_rate) -> None:  # type: ignore
-                super()._report(metric, metric_type, value, tags, sample_rate)
-                self.emitted: Dict[str, Any] = dict()
-                self.emitted[metric] = self.emitted.setdefault(metric, 0) + 1
+            def _report(self, *args, **kwargs) -> None:  # type: ignore
+                super()._report(*args, **kwargs)
+                # Capture the metric name and increment its count for debugging
+                if metric := kwargs.get("metric"):
+                    self.emitted: Dict[str, Any] = dict()
+                    self.emitted[metric] = self.emitted.setdefault(metric, 0) + 1
 
         module: Optional[CustomStatsd]
         module = CustomStatsd()

{sovereign-1.0.0b103 → sovereign-1.0.0b106}/src/sovereign/views/api.py

@@ -37,8 +37,8 @@ async def resource(
 ) -> Response:
     expressions = [f"cluster={service_cluster}"]
     try:
-        metadata = json.loads(metadata or "{}")
-        for expr in expand_metadata_to_expr(metadata):
+        data = {"metadata": json.loads(metadata or "{}")}
+        for expr in expand_metadata_to_expr(data):
             expressions.append(expr)
     except Exception:
         pass
@@ -51,7 +51,6 @@ async def resource(
         expressions=expressions,
     )
     req = mock_discovery_request(**{k: v for k, v in kwargs.items() if v is not None})
-    print(req)
     response = await cache.blocking_read(req)
     if content := getattr(response, "text", None):
         return Response(content, media_type="application/json")