sovereign 0.29.3__py3-none-any.whl → 0.30.0__py3-none-any.whl

sovereign/__init__.py

@@ -1,46 +1,26 @@
 import os
+import sys
 from contextvars import ContextVar
 from importlib.metadata import version
-from typing import Any, Mapping, Type
+from typing import Optional
 
-from fastapi.responses import JSONResponse
 from pydantic import ValidationError
 from starlette.templating import Jinja2Templates
 
-from sovereign import dynamic_config
 from sovereign.context import TemplateContext
 from sovereign.logging.bootstrapper import LoggerBootstrapper
-from sovereign.schemas import SovereignAsgiConfig, SovereignConfig, SovereignConfigv2
+from sovereign.schemas import (
+    SovereignAsgiConfig,
+    SovereignConfig,
+    SovereignConfigv2,
+    migrate_configs,
+    parse_raw_configuration,
+)
 from sovereign.sources import SourcePoller
 from sovereign.statistics import configure_statsd
 from sovereign.utils.crypto.crypto import CipherContainer
-from sovereign.utils.dictupdate import merge  # type: ignore
 from sovereign.utils.resources import get_package_file
 
-json_response_class: Type[JSONResponse] = JSONResponse
-try:
-    import orjson
-    from fastapi.responses import ORJSONResponse
-
-    json_response_class = ORJSONResponse
-except ImportError:
-    try:
-        import ujson
-        from fastapi.responses import UJSONResponse
-
-        json_response_class = UJSONResponse
-    except ImportError:
-        pass
-
-
-def parse_raw_configuration(path: str) -> Mapping[Any, Any]:
-    ret: Mapping[Any, Any] = dict()
-    for p in path.split(","):
-        spec = dynamic_config.Loadable.from_legacy_fmt(p)
-        ret = merge(obj_a=ret, obj_b=spec.load(), merge_lists=True)
-    return ret
-
-
 _request_id_ctx_var: ContextVar[str] = ContextVar("request_id", default="")
 
 
@@ -57,6 +37,9 @@ html_templates = Jinja2Templates(
     directory=str(get_package_file(DIST_NAME, "templates"))
 )
 
+if sys.argv[0].endswith("sovereign"):
+    migrate_configs()
+
 try:
     config = SovereignConfigv2(**parse_raw_configuration(config_path))
 except ValidationError:
@@ -69,15 +52,25 @@ logs = LoggerBootstrapper(config)
 application_logger = logs.application_logger.logger
 
 stats = configure_statsd(config=config.statsd)
-poller = SourcePoller(
-    sources=config.sources,
-    matching_enabled=config.matching.enabled,
-    node_match_key=config.matching.node_key,
-    source_match_key=config.matching.source_key,
-    source_refresh_rate=config.source_config.refresh_rate,
-    logger=application_logger,
-    stats=stats,
-)
+poller = None
+if config.sources is not None:
+    if config.matching is not None:
+        matching_enabled = config.matching.enabled
+        node_key: Optional[str] = config.matching.node_key
+        source_key: Optional[str] = config.matching.source_key
+    else:
+        matching_enabled = False
+        node_key = None
+        source_key = None
+    poller = SourcePoller(
+        sources=config.sources,
+        matching_enabled=matching_enabled,
+        node_match_key=node_key,
+        source_match_key=source_key,
+        source_refresh_rate=config.source_config.refresh_rate,
+        logger=application_logger,
+        stats=stats,
+    )
 
 encryption_configs = config.authentication.encryption_configs
 server_cipher_container = CipherContainer.from_encryption_configs(
@@ -95,5 +88,6 @@ template_context = TemplateContext(
     logger=application_logger,
     stats=stats,
 )
-poller.lazy_load_modifiers(config.modifiers)
-poller.lazy_load_global_modifiers(config.global_modifiers)
+if poller is not None:
+    poller.lazy_load_modifiers(config.modifiers)
+    poller.lazy_load_global_modifiers(config.global_modifiers)

sovereign/app.py

@@ -4,24 +4,22 @@ from collections import namedtuple
 
 import uvicorn
 from fastapi import FastAPI, Request
-from fastapi.responses import RedirectResponse, FileResponse, Response, JSONResponse
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse, Response
+from starlette_context.middleware import RawContextMiddleware
 
 from sovereign import (
     __version__,
-    config,
     asgi_config,
-    json_response_class,
+    config,
+    logs,
     poller,
     template_context,
-    logs,
 )
+from sovereign.response_class import json_response_class
 from sovereign.error_info import ErrorInfo
+from sovereign.middlewares import LoggingMiddleware, RequestContextLogMiddleware
 from sovereign.utils.resources import get_package_file
-from sovereign.views import crypto, discovery, healthchecks, admin, interface
-from sovereign.middlewares import (
-    RequestContextLogMiddleware,
-    LoggingMiddleware,
-)
+from sovereign.views import admin, crypto, discovery, healthchecks, interface
 
 Router = namedtuple("Router", "module tags prefix")
 
@@ -89,6 +87,8 @@ def init_app() -> FastAPI:
         application.add_middleware(SentryAsgiMiddleware)
         logs.application_logger.logger.info("Sentry middleware enabled")
 
+    application.add_middleware(RawContextMiddleware)
+
     @application.exception_handler(500)
     async def exception_handler(_: Request, exc: Exception) -> JSONResponse:
         """
@@ -109,7 +109,8 @@ def init_app() -> FastAPI:
 
     @application.on_event("startup")
     async def keep_sources_uptodate() -> None:
-        asyncio.create_task(poller.poll_forever())
+        if poller is not None:
+            asyncio.create_task(poller.poll_forever())
 
     @application.on_event("startup")
     async def refresh_template_context() -> None:

sovereign/context.py

@@ -1,4 +1,5 @@
 import asyncio
+import warnings
 import traceback
 from copy import deepcopy
 from typing import (
@@ -37,7 +38,7 @@ class TemplateContext:
         refresh_num_retries: int,
         refresh_retry_interval_secs: int,
         configured_context: Dict[str, Loadable],
-        poller: SourcePoller,
+        poller: Optional[SourcePoller],
         encryption_suite: Optional[CipherContainer],
         logger: BoundLogger,
         stats: Any,
@@ -121,41 +122,45 @@ class TemplateContext:
         if "crypto" not in self.context and self.crypto:
             self.context["crypto"] = self.crypto
 
-    def build_new_context_from_instances(self, node_value: str) -> Dict[str, Any]:
-        matches = self.poller.match_node(node_value=node_value)
+    def build_new_context_from_instances(
+        self, node_value: Optional[str]
+    ) -> Dict[str, Any]:
+        to_add = dict()
+        if self.poller is not None:
+            matches = self.poller.match_node(node_value=node_value)
+            for scope, instances in matches.scopes.items():
+                if scope in ("default", None):
+                    to_add["instances"] = instances
+                else:
+                    to_add[scope] = instances
+            if to_add == {}:
+                raise HTTPException(
+                    detail=(
+                        "This node does not match any instances! ",
+                        "If node matching is enabled, check that the node "
+                        "match key aligns with the source match key. "
+                        "If you don't know what any of this is, disable "
+                        "node matching via the config",
+                    ),
+                    status_code=400,
+                )
         ret = dict()
         for key, value in self.context.items():
             try:
                 ret[key] = deepcopy(value)
             except TypeError:
                 ret[key] = value
-
-        to_add = dict()
-        for scope, instances in matches.scopes.items():
-            if scope in ("default", None):
-                to_add["instances"] = instances
-            else:
-                to_add[scope] = instances
-        if to_add == {}:
-            raise HTTPException(
-                detail=(
-                    "This node does not match any instances! ",
-                    "If node matching is enabled, check that the node "
-                    "match key aligns with the source match key. "
-                    "If you don't know what any of this is, disable "
-                    "node matching via the config",
-                ),
-                status_code=400,
-            )
         ret.update(to_add)
         return ret
 
     def get_context(
         self, request: DiscoveryRequest, template: XdsTemplate
     ) -> Dict[str, Any]:
-        ret = self.build_new_context_from_instances(
-            node_value=self.poller.extract_node_key(request.node),
-        )
+        ret = {}
+        node_value = None
+        if self.poller is not None and self.poller.node_match_key is not None:
+            node_value = self.poller.extract_node_key(request.node)
+        ret = self.build_new_context_from_instances(node_value=node_value)
         ret["__hide_from_ui"] = lambda v: v
         if request.hide_private_keys:
             ret["__hide_from_ui"] = lambda _: "(value hidden)"
@@ -178,4 +183,12 @@ class TemplateContext:
                 yield key
 
     def get(self, *args: Any, **kwargs: Any) -> Any:
+        warnings.warn(
+            (
+                "Accessing values from template_context directly is deprecated and "
+                "will be removed in a future release."
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return self.context.get(*args, **kwargs)

sovereign/discovery.py

@@ -6,12 +6,14 @@ Functions used to render and return discovery responses to Envoy proxies.
 
 The templates are configurable. `todo See ref:Configuration#Templates`
 """
+
+import warnings
 from enum import Enum
-from typing import List, Dict, Any, Optional
+from typing import Any, Dict, List, Optional
 
 import yaml
-from yaml.parser import ParserError, ScannerError  # type: ignore
 from starlette.exceptions import HTTPException
+from yaml.parser import ParserError, ScannerError  # type: ignore
 
 try:
     import sentry_sdk
@@ -20,21 +22,18 @@ try:
 except ImportError:
     SENTRY_INSTALLED = False
 
-from sovereign import XDS_TEMPLATES, config, logs, template_context
+from sovereign import XDS_TEMPLATES, config, template_context, logs
+from sovereign.schemas import DiscoveryRequest, ProcessedTemplate, XdsTemplate
 from sovereign.utils.version_info import compute_hash
-from sovereign.schemas import XdsTemplate, DiscoveryRequest, ProcessedTemplate
-
 
 try:
     default_templates = XDS_TEMPLATES["default"]
 except KeyError:
-    raise KeyError(
+    warnings.warn(
         "Your configuration should contain default templates. For more details, see "
-        "https://vsyrakis.bitbucket.io/sovereign/docs/html/guides/tutorial.html#create-templates "
+        "https://developer.atlassian.com/platform/sovereign/tutorial/templates/#versioning-templates"
     )
 
-cache_strategy = config.source_config.cache_strategy
-
 # Create an enum that bases all the available discovery types off what has been configured
 discovery_types = (_type for _type in sorted(XDS_TEMPLATES["__any__"].keys()))
 discovery_types_base: Dict[str, str] = {t: t for t in discovery_types}

sovereign/dynamic_config/deser.py

@@ -34,8 +34,7 @@ class ConfigDeserializer(Protocol):
             path: ...
     """
 
-    def deserialize(self, input: Any) -> Any:
-        ...
+    def deserialize(self, input: Any) -> Any: ...
 
 
 class YamlDeserializer(ConfigDeserializer):

sovereign/dynamic_config/loaders.py

@@ -31,8 +31,7 @@ class CustomLoader(Protocol):
 
     default_deser: str = "yaml"
 
-    def load(self, path: str) -> Any:
-        ...
+    def load(self, path: str) -> Any: ...
 
 
 class File(CustomLoader):

sovereign/logging/access_logger.py

@@ -1,7 +1,9 @@
+from copy import deepcopy
 from functools import cached_property
 from typing import Any, Dict
 
 import structlog
+from starlette_context import context
 from structlog.stdlib import BoundLogger
 
 from sovereign.logging.base_logger import BaseLogger
@@ -20,7 +22,7 @@ class AccessLogger(BaseLogger):
             wrapper_class=structlog.BoundLogger,
             processors=[
                 self.is_enabled_processor,
-                self.merge_in_threadlocal,
+                self.merge_starlette_contextvars,
                 self.format_access_log_fields,
             ],
             type=LoggingType.ACCESS,
@@ -70,3 +72,14 @@ class AccessLogger(BaseLogger):
                 continue
             formatted_dict[k] = value
         return formatted_dict
+
+    def merge_starlette_contextvars(
+        self, _, __, event_dict: EventDict
+    ) -> ProcessedMessage:
+        merged_context = deepcopy(event_dict)
+        for k, v in context.data.items():
+            merged_context[k] = v
+        return merged_context
+
+    def queue_log_fields(self, **kwargs: Any) -> None:
+        context.update(kwargs)

sovereign/logging/application_logger.py

@@ -19,7 +19,6 @@ class ApplicationLogger(BaseLogger):
             wrapper_class=structlog.BoundLogger,
             processors=[
                 self.is_enabled_processor,
-                self.merge_in_threadlocal,
                 self.format_application_log_fields,
             ],
             type=LoggingType.APPLICATION,

sovereign/logging/base_logger.py

@@ -1,29 +1,24 @@
 import json
-import threading
 from abc import ABC, abstractmethod
 from functools import cached_property
-from typing import Any, Dict, Optional
+from typing import Dict, Optional
 
 from structlog.exceptions import DropEvent
 from structlog.stdlib import BoundLogger
 
 from sovereign.logging.types import EventDict, ProcessedMessage
 
-LOG_QUEUE = threading.local()
-
 
 class BaseLogger(ABC):
     _user_log_fmt: Optional[str]
 
     @property
     @abstractmethod
-    def is_enabled(self) -> bool:
-        ...
+    def is_enabled(self) -> bool: ...
 
     @property
     @abstractmethod
-    def _default_log_fmt(self) -> Dict[str, str]:
-        ...
+    def _default_log_fmt(self) -> Dict[str, str]: ...
 
     def is_enabled_processor(
         self, logger: BoundLogger, method_name: str, event_dict: EventDict
@@ -44,22 +39,3 @@ class BaseLogger(ABC):
                 format["event"] = "{event}"
             return format
         return self._default_log_fmt
-
-    def merge_in_threadlocal(
-        self, logger: Any, method_name: str, event_dict: EventDict
-    ) -> ProcessedMessage:
-        self._ensure_threadlocal()
-        fields: Dict[str, Any] = LOG_QUEUE.fields.copy()
-        fields.update(event_dict)
-        return fields
-
-    def clear_log_fields(self) -> None:
-        LOG_QUEUE.fields = dict()
-
-    def _ensure_threadlocal(self) -> None:
-        if not hasattr(LOG_QUEUE, "fields"):
-            LOG_QUEUE.fields = dict()
-
-    def queue_log_fields(self, **kwargs: Any) -> None:
-        self._ensure_threadlocal()
-        LOG_QUEUE.fields.update(kwargs)

sovereign/logging/bootstrapper.py

@@ -29,6 +29,6 @@ class LoggerBootstrapper:
     def debug_logs_processor(
         self, logger: BoundLogger, method_name: str, event_dict: EventDict
     ) -> ProcessedMessage:
-        if method_name == "debug" and self.show_debug == False:
+        if method_name == "debug" and self.show_debug is False:
             raise DropEvent
         return event_dict

sovereign/middlewares.py

@@ -1,10 +1,12 @@
 import os
 import time
 from uuid import uuid4
+
 from fastapi.requests import Request
 from fastapi.responses import Response
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from sovereign import config, logs, get_request_id, _request_id_ctx_var, stats
+
+from sovereign import _request_id_ctx_var, config, get_request_id, logs, stats
 
 
 class RequestContextLogMiddleware(BaseHTTPMiddleware):
@@ -36,7 +38,6 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             source_port = addr.port
         if xff := request.headers.get("X-Forwarded-For"):
             source_ip = xff.split(",")[0]  # leftmost address
-        logs.access_logger.clear_log_fields()
         logs.access_logger.queue_log_fields(
             ENVIRONMENT=config.legacy_fields.environment,
             HOST=request.headers.get("host", "-"),

sovereign/modifiers/lib.py

@@ -6,6 +6,7 @@ used via configuration.
 
 `todo entry point install guide`
 """
+
 import abc
 from typing import List, Any, Dict