sovereign 0.27.0__tar.gz → 0.29.0__tar.gz

{sovereign-0.27.0 → sovereign-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sovereign
-Version: 0.27.0
+Version: 0.29.0
 Summary: Envoy Proxy control-plane written in Python
 Home-page: https://pypi.org/project/sovereign/
 License: Apache-2.0
@@ -18,6 +18,7 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -37,7 +38,7 @@ Requires-Dist: cachelib (>=0.10.2,<0.11.0)
 Requires-Dist: cachetools (>=5.3.2,<6.0.0)
 Requires-Dist: cashews[redis] (>=6.3.0,<7.0.0) ; extra == "caching"
 Requires-Dist: croniter (>=1.4.1,<2.0.0)
-Requires-Dist: cryptography (>=42.0.5,<43.0.0)
+Requires-Dist: cryptography (>=43.0.1,<44.0.0)
 Requires-Dist: datadog (>=0.47.0,<0.48.0) ; extra == "statsd"
 Requires-Dist: fastapi (>=0.110.0,<0.111.0)
 Requires-Dist: glom (>=23.3.0,<24.0.0)

{sovereign-0.27.0 → sovereign-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sovereign"
-version = "0.27.0"
+version = "0.29.0"
 description = "Envoy Proxy control-plane written in Python"
 license = "Apache-2.0"
 packages = [
@@ -41,6 +41,26 @@ sovereign = 'sovereign.server:main'
 
 [tool.poetry.plugins."sovereign.loaders"]
 "example" = "sovereign.testing.loaders:Multiply"
+"file" = "sovereign.dynamic_config.loaders:File"
+"pkgdata" = "sovereign.dynamic_config.loaders:PackageData"
+"http" = "sovereign.dynamic_config.loaders:Web"
+"https" = "sovereign.dynamic_config.loaders:Web"
+"env" = "sovereign.dynamic_config.loaders:EnvironmentVariable"
+"module" = "sovereign.dynamic_config.loaders:PythonModule"
+"s3" = "sovereign.dynamic_config.loaders:S3Bucket"
+"python" = "sovereign.dynamic_config.loaders:PythonInlineCode"
+"inline" = "sovereign.dynamic_config.loaders:Inline"
+
+[tool.poetry.plugins."sovereign.deserializers"]
+"yaml" = "sovereign.dynamic_config.deser:YamlDeserializer"
+"json" = "sovereign.dynamic_config.deser:JsonDeserializer"
+"jinja" = "sovereign.dynamic_config.deser:JinjaDeserializer"
+"jinja2" = "sovereign.dynamic_config.deser:JinjaDeserializer"
+"string" = "sovereign.dynamic_config.deser:StringDeserializer"
+"raw" = "sovereign.dynamic_config.deser:PassthroughDeserializer"
+"ujson" = "sovereign.dynamic_config.deser:UjsonDeserializer"
+"orjson" = "sovereign.dynamic_config.deser:OrjsonDeserializer"
+
 
 [tool.poetry.dependencies]
 python = "^3.11"
@@ -53,7 +73,7 @@ Jinja2 = "^3.1.2"
 structlog = "^23.1.0"
 cachelib = "^0.10.2"
 glom = "^23.3.0"
-cryptography = "^42.0.5"
+cryptography = "^43.0.1"
 fastapi = "^0.110.0"
 uvloop = "^0.19.0"
 sentry-sdk = "^1.23.1"

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/__init__.py

@@ -7,7 +7,7 @@ from fastapi.responses import JSONResponse
 from pydantic import ValidationError
 from starlette.templating import Jinja2Templates
 
-from sovereign import config_loader
+from sovereign import dynamic_config
 from sovereign.context import TemplateContext
 from sovereign.logging.bootstrapper import LoggerBootstrapper
 from sovereign.schemas import SovereignAsgiConfig, SovereignConfig, SovereignConfigv2
@@ -36,7 +36,7 @@ except ImportError:
 def parse_raw_configuration(path: str) -> Mapping[Any, Any]:
     ret: Mapping[Any, Any] = dict()
     for p in path.split(","):
-        spec = config_loader.Loadable.from_legacy_fmt(p)
+        spec = dynamic_config.Loadable.from_legacy_fmt(p)
         ret = merge(obj_a=ret, obj_b=spec.load(), merge_lists=True)
     return ret
 

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/configuration.py

@@ -3,7 +3,7 @@ from typing import Any, Mapping
 
 from pydantic import ValidationError
 
-from sovereign import config_loader
+from sovereign import dynamic_config
 from sovereign.context import TemplateContext
 from sovereign.logging.bootstrapper import LoggerBootstrapper
 from sovereign.schemas import SovereignAsgiConfig, SovereignConfig, SovereignConfigv2
@@ -16,7 +16,7 @@ from sovereign.utils.dictupdate import merge  # type: ignore
 def parse_raw_configuration(path: str) -> Mapping[Any, Any]:
     ret: Mapping[Any, Any] = dict()
     for p in path.split(","):
-        spec = config_loader.Loadable.from_legacy_fmt(p)
+        spec = dynamic_config.Loadable.from_legacy_fmt(p)
         ret = merge(obj_a=ret, obj_b=spec.load(), merge_lists=True)
     return ret
 

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/context.py

@@ -13,11 +13,9 @@ from typing import (
 )
 
 from fastapi import HTTPException
-from sovereign import config_loader
-from sovereign.utils.entry_point_loader import EntryPointLoader
 from structlog.stdlib import BoundLogger
 
-from sovereign.config_loader import Loadable
+from sovereign.dynamic_config import Loadable
 from sovereign.schemas import DiscoveryRequest, EncryptionConfig, XdsTemplate
 from sovereign.sources import SourcePoller
 from sovereign.utils.crypto.crypto import CipherContainer
@@ -55,14 +53,6 @@ class TemplateContext:
         self.stats = stats
         # initial load
         self.context: Dict[str, Any] = {}
-        entry_points = EntryPointLoader("loaders")
-        for entry_point in entry_points.groups["loaders"]:
-            custom_loader = entry_point.load()
-            try:
-                func = custom_loader.load
-            except AttributeError:
-                raise AttributeError("Custom loader does not implement .load()")
-            config_loader.loaders[entry_point.name] = func
         asyncio.run(self.load_context_variables())
 
     async def start_refresh_context(self) -> NoReturn:

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/discovery.py

@@ -163,6 +163,8 @@ def filter_resources(
     that does not match the name of the resource.
     If Envoy did not specifically request anything, every resource is retained.
     """
+    if len(requested) == 0:
+        return generated
     return [resource for resource in generated if resource_name(resource) in requested]
 
 

sovereign-0.29.0/src/sovereign/dynamic_config/__init__.py

@@ -0,0 +1,88 @@
+import inspect
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel
+
+from sovereign.utils.entry_point_loader import EntryPointLoader
+from sovereign.dynamic_config.loaders import CustomLoader
+from sovereign.dynamic_config.deser import ConfigDeserializer
+
+
+class Loadable(BaseModel):
+    path: str
+    protocol: str
+    serialization: Optional[str] = None
+
+    def load(self, default: Any = None) -> Any:
+        if self.protocol not in LOADERS:
+            raise KeyError(
+                f"Could not find CustomLoader {self.protocol}. Available: {LOADERS}"
+            )
+        loader_ = LOADERS[self.protocol]
+
+        ser = self.serialization
+        if ser is None:
+            ser = loader_.default_deser
+        if ser not in DESERIALIZERS:
+            raise KeyError(
+                f"Could not find Deserializer {ser}. Available: {DESERIALIZERS}"
+            )
+        deserializer = DESERIALIZERS[ser]
+
+        try:
+            data = loader_.load(self.path)
+            return deserializer.deserialize(data)
+        except Exception as original_error:
+            if default is not None:
+                return default
+            raise Exception(
+                f"{self.protocol=}, {self.path=}, {self.serialization=}, {original_error=}"
+            )
+
+    @staticmethod
+    def from_legacy_fmt(fmt_string: str) -> "Loadable":
+        if "://" not in fmt_string:
+            return Loadable(protocol="inline", serialization="string", path=fmt_string)
+        try:
+            scheme, path = fmt_string.split("://")
+        except ValueError:
+            raise ValueError(fmt_string)
+        try:
+            proto, ser = scheme.split("+")
+        except ValueError:
+            proto, ser = scheme, "yaml"
+
+        if proto in ("python", "module"):
+            ser = "raw"
+        if proto in ("http", "https"):
+            path = "://".join([proto, path])
+
+        return Loadable(
+            protocol=proto,
+            serialization=ser,
+            path=path,
+        )
+
+
+LOADERS: Dict[str, CustomLoader] = {}
+for entry_point in EntryPointLoader("loaders").groups["loaders"]:
+    custom_loader = entry_point.load()
+    func = custom_loader()
+    method = getattr(func, "load")
+    if not inspect.ismethod(method):
+        raise AttributeError(
+            f"CustomLoader {entry_point.name} does not implement .load()"
+        )
+    LOADERS[entry_point.name] = func
+
+
+DESERIALIZERS: Dict[str, ConfigDeserializer] = {}
+for entry_point in EntryPointLoader("deserializers").groups["deserializers"]:
+    deserializer = entry_point.load()
+    func = deserializer()
+    method = getattr(func, "deserialize")
+    if not inspect.ismethod(method):
+        raise AttributeError(
+            f"Deserializer {entry_point.name} does not implement .deserialize()"
+        )
+    DESERIALIZERS[entry_point.name] = func

sovereign-0.29.0/src/sovereign/dynamic_config/deser.py

@@ -0,0 +1,79 @@
+import json
+from typing import Any, Protocol
+
+import yaml
+import jinja2
+
+try:
+    import ujson
+
+    UJSON_AVAILABLE = True
+except ImportError:
+    UJSON_AVAILABLE = False
+
+try:
+    import orjson
+
+    ORJSON_AVAILABLE = True
+except ImportError:
+    ORJSON_AVAILABLE = False
+
+jinja_env = jinja2.Environment(autoescape=True)
+
+
+class ConfigDeserializer(Protocol):
+    """
+    Deserializers can be added to sovereign by creating a subclass
+    and then specified in config:
+
+    template_context:
+      context:
+          ...:
+            protocol: ...
+            serialization: <serializer name>
+            path: ...
+    """
+
+    def deserialize(self, input: Any) -> Any:
+        ...
+
+
+class YamlDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        return yaml.safe_load(input)
+
+
+class JsonDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        return json.loads(input)
+
+
+class JinjaDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        return jinja_env.from_string(input)
+
+
+class StringDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        return str(input)
+
+
+class PassthroughDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        return input
+
+
+class UjsonDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        if not UJSON_AVAILABLE:
+            raise ImportError("Configured a UJSON deserializer but it's not installed")
+        return ujson.loads(input)
+
+
+class OrjsonDeserializer(ConfigDeserializer):
+    def deserialize(self, input: Any) -> Any:
+        if not ORJSON_AVAILABLE:
+            raise ImportError(
+                "Configured an ORJSON deserializer but it's not installed"
+            )
+        return orjson.loads(input)

sovereign-0.29.0/src/sovereign/dynamic_config/loaders.py

@@ -0,0 +1,121 @@
+import os
+import importlib
+from typing import Any, Protocol
+from pathlib import Path
+from importlib.machinery import SourceFileLoader
+
+import requests
+
+from sovereign.utils.resources import get_package_file_bytes
+
+try:
+    import boto3
+
+    BOTO_IS_AVAILABLE = True
+except ImportError:
+    BOTO_IS_AVAILABLE = False
+
+
+class CustomLoader(Protocol):
+    """
+    Custom loaders can be added to sovereign by creating a subclass
+    and then in config:
+
+    template_context:
+      context:
+          ...:
+            protocol: <loader name>
+            serialization: ...
+            path: <path argument>
+    """
+
+    default_deser: str = "yaml"
+
+    def load(self, path: str) -> Any:
+        ...
+
+
+class File(CustomLoader):
+    default_deser = "passthrough"
+
+    def load(self, path: str) -> Any:
+        with open(path) as f:
+            contents = f.read()
+            try:
+                return contents
+            except FileNotFoundError:
+                raise FileNotFoundError(f"Unable to load {path}")
+
+
+class PackageData(CustomLoader):
+    default_deser = "string"
+
+    def load(self, path: str) -> Any:
+        pkg, pkg_file = path.split(":")
+        data = get_package_file_bytes(pkg, pkg_file)
+        return data
+
+
+class Web(CustomLoader):
+    default_deser = "json"
+
+    def load(self, path: str) -> Any:
+        response = requests.get(path)
+        response.raise_for_status()
+        data = response.text
+        return data
+
+
+class EnvironmentVariable(CustomLoader):
+    default_deser = "raw"
+
+    def load(self, path: str) -> Any:
+        data = os.getenv(path)
+        if data is None:
+            raise AttributeError(f"Unable to read environment variable {path}")
+        return data
+
+
+class PythonModule(CustomLoader):
+    default_deser = "passthrough"
+
+    def load(self, path: str) -> Any:
+        if ":" in path:
+            mod, fn = path.rsplit(":", maxsplit=1)
+        else:
+            mod, fn = path, ""
+        imported = importlib.import_module(mod)
+        if fn != "":
+            return getattr(imported, fn)
+        return imported
+
+
+class S3Bucket(CustomLoader):
+    default_deser = "raw"
+
+    def load(self, path: str) -> Any:
+        if not BOTO_IS_AVAILABLE:
+            raise ImportError(
+                "boto3 must be installed to load S3 paths. Use ``pip install sovereign[boto]``"
+            )
+        bucket, key = path.split("/", maxsplit=1)
+        s3 = boto3.client("s3")
+        response = s3.get_object(Bucket=bucket, Key=key)
+        data = "".join([chunk.decode() for chunk in response["Body"]])
+        return data
+
+
+class PythonInlineCode(CustomLoader):
+    default_deser = "passthrough"
+
+    def load(self, path: str) -> Any:
+        p = str(Path(path).absolute())
+        loader = SourceFileLoader(p, path=p)
+        return loader.load_module(p)
+
+
+class Inline(CustomLoader):
+    default_deser = "string"
+
+    def load(self, path: str) -> Any:
+        return path

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/schemas.py

@@ -20,7 +20,8 @@ from pydantic import (
 )
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from sovereign.config_loader import Loadable, Serialization, jinja_env
+from sovereign.dynamic_config import Loadable
+from sovereign.dynamic_config.deser import jinja_env
 from sovereign.utils.crypto.suites import EncryptionType
 from sovereign.utils.version_info import compute_hash
 
@@ -111,6 +112,7 @@ class DiscoveryCacheConfig(BaseModel):
     suppress: bool = False  # False = Don't suppress connection errors. True = suppress connection errors
     socket_keepalive: bool = True  # Try to keep connections to redis around.
     ttl: int = 60
+    extra_keys: Dict[str, Any] = {}
 
     @model_validator(mode="after")
     def set_default_protocol(self) -> Self:
@@ -164,15 +166,15 @@ class XdsTemplate:
             return self.code.render(*args, **kwargs)
 
     def load_source(self) -> str:
-        if self.loadable.serialization in (Serialization.jinja, Serialization.jinja2):
+        old_serialization = self.loadable.serialization
+        if self.loadable.serialization in ("jinja", "jinja2"):
             # The Jinja2 template serializer does not properly set a name
             # for the loaded template.
             # The repr for the template prints out as the memory address
             # This makes it really hard to generate a consistent version_info string
             # in rendered configuration.
             # For this reason, we re-load the template as a string instead, and create a checksum.
-            old_serialization = self.loadable.serialization
-            self.loadable.serialization = Serialization("string")
+            self.loadable.serialization = "string"
             ret = self.loadable.load()
             self.loadable.serialization = old_serialization
             return str(ret)
@@ -180,9 +182,8 @@ class XdsTemplate:
             # If the template specified is a python source file,
             # we can simply read and return the source of it.
             old_protocol = self.loadable.protocol
-            old_serialization = self.loadable.serialization
             self.loadable.protocol = "inline"
-            self.loadable.serialization = Serialization("string")
+            self.loadable.serialization = "string"
             ret = self.loadable.load()
             self.loadable.protocol = old_protocol
             self.loadable.serialization = old_serialization
@@ -294,7 +295,9 @@ class Resources(List[str]):
     """
 
     def __contains__(self, item: object) -> bool:
-        if len(self) == 0:
+        if (
+            len(self) == 0
+        ):  # TODO: refactor to remove overriding __contains__; its being used in multiple places
             return True
         return super().__contains__(item)
 
@@ -305,13 +308,17 @@ class Status(BaseModel):
     details: List[Any]
 
 
+def resources_factory() -> Resources:
+    return Resources()
+
+
 class DiscoveryRequest(BaseModel):
     node: Node = Field(..., title="Node information about the envoy proxy")
     version_info: str = Field(
         "0", title="The version of the envoy clients current configuration"
     )
-    resource_names: list[str] | Resources = Field(
-        Resources(), title="List of requested resource names"
+    resource_names: Resources = Field(
+        default_factory=resources_factory, title="List of requested resource names"
     )
     hide_private_keys: bool = False
     type_url: Optional[str] = Field(
@@ -353,6 +360,11 @@ class DiscoveryRequest(BaseModel):
             self.desired_controlplane,
         )
 
+    @field_validator("resource_names", mode="before")
+    @classmethod
+    def validate_resources(cls, v: Union[Resources, List[str]]) -> Resources:
+        return Resources(v)
+
 
 class DiscoveryResponse(BaseModel):
     version_info: str = Field(
@@ -447,6 +459,7 @@ class SovereignConfig(BaseSettings):
     log_fmt: Optional[str] = Field("", alias="SOVEREIGN_LOG_FORMAT")
     ignore_empty_log_fields: bool = Field(False, alias="SOVEREIGN_LOG_IGNORE_EMPTY")
     discovery_cache: DiscoveryCacheConfig = DiscoveryCacheConfig()
+    tracing: Optional["TracingConfig"] = None
     model_config = SettingsConfigDict(
         env_file=".env",
         extra="ignore",
@@ -633,6 +646,46 @@ class SourcesConfiguration(BaseSettings):
     )
 
 
+class TracingConfig(BaseSettings):
+    enabled: bool = Field(False)
+    collector: str = Field("notset")
+    endpoint: str = Field("/v2/api/spans")
+    trace_id_128bit: bool = Field(True)
+    tags: Dict[str, Union[Loadable, str]] = dict()
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        extra="ignore",
+        env_file_encoding="utf-8",
+        populate_by_name=True,
+    )
+
+    @field_validator("tags", mode="before")
+    @classmethod
+    def load_tags(cls, v: Dict[str, Union[Loadable, str]]) -> Dict[str, Any]:
+        ret = dict()
+        for key, value in v.items():
+            if isinstance(value, dict):
+                ret[key] = Loadable(**value).load()
+            elif isinstance(value, str):
+                ret[key] = Loadable.from_legacy_fmt(value).load()
+            else:
+                raise ValueError(f"Received an invalid tag for tracing: {value}")
+        return ret
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_environmental_variables(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        if enabled := getenv("SOVEREIGN_TRACING_ENABLED"):
+            values["enabled"] = enabled
+        if collector := getenv("SOVEREIGN_TRACING_COLLECTOR"):
+            values["collector"] = collector
+        if endpoint := getenv("SOVEREIGN_TRACING_ENDPOINT"):
+            values["endpoint"] = endpoint
+        if trace_id_128bit := getenv("SOVEREIGN_TRACING_TRACE_ID_128BIT"):
+            values["trace_id_128bit"] = trace_id_128bit
+        return values
+
+
 class LegacyConfig(BaseSettings):
     regions: Optional[List[str]] = None
     eds_priority_matrix: Optional[Dict[str, Dict[str, int]]] = None
@@ -720,6 +773,7 @@ class SovereignConfigv2(BaseSettings):
     debug: bool = Field(False, alias="SOVEREIGN_DEBUG")
     legacy_fields: LegacyConfig = LegacyConfig()
     discovery_cache: DiscoveryCacheConfig = DiscoveryCacheConfig()
+    tracing: TracingConfig = TracingConfig()
     model_config = SettingsConfigDict(
         env_file=".env",
         extra="ignore",
@@ -810,6 +864,7 @@ class SovereignConfigv2(BaseSettings):
             statsd=other.statsd,
             sentry_dsn=SecretStr(other.sentry_dsn),
             debug=other.debug_enabled,
+            tracing=other.tracing,
             legacy_fields=LegacyConfig(
                 regions=other.regions,
                 eds_priority_matrix=other.eds_priority_matrix,

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/sources/file.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict
 from sovereign.sources.lib import Source
-from sovereign.config_loader import Loadable
+from sovereign.dynamic_config import Loadable
 
 
 class File(Source):

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/templates/resources.html

@@ -88,14 +88,24 @@
             1: 'resource'
         } %}
         {% for resource in res %}
+            {% if "sovereign_error" in resource %}
+                <span class="panel-icon">
+                    <i class="fas fa-arrow-right" aria-hidden="true"></i>
+                </span>
+                <div class="notification is-danger">
+                    {{ resource["sovereign_error"] }}
+                </div>
+                {{ resource["sovereign_error"] }}
+            {% else %}
             {% set name = resource.get('name') or resource['cluster_name'] %}
             <a class="panel-block has-text-weight-medium"
-               href="/ui/resources/{{ resource_type }}/{{ name }}">
-        <span class="panel-icon">
-            <i class="fas fa-arrow-right" aria-hidden="true"></i>
-        </span>
-                {{ name }}
-            </a>
+                   href="/ui/resources/{{ resource_type }}/{{ name }}">
+                    <span class="panel-icon">
+                        <i class="fas fa-arrow-right" aria-hidden="true"></i>
+                    </span>
+                    {{ name }}
+                </a>
+            {% endif %}
         {% endfor %}
         <div class="panel-block">
             <p class="content is-small">

sovereign-0.29.0/src/sovereign/testing/loaders.py

@@ -0,0 +1,8 @@
+from typing import Any
+from sovereign.dynamic_config.loaders import CustomLoader
+
+
+class Multiply(CustomLoader):
+    def load(self, path: str) -> Any:
+        result = path * 2
+        return result

sovereign-0.29.0/src/sovereign/tracing.py

@@ -0,0 +1,85 @@
+import time
+import uuid
+import requests
+from contextvars import ContextVar
+from contextlib import nullcontext
+
+from sovereign import config
+
+_trace_id_ctx_var: ContextVar[str] = ContextVar("trace_id", default="")
+_span_id_ctx_var: ContextVar[str] = ContextVar("span_id", default="")
+
+
+def get_trace_id() -> str:
+    return _trace_id_ctx_var.get()
+
+
+def get_span_id() -> str:
+    return _span_id_ctx_var.get()
+
+
+def generate_128bit():
+    return str(uuid.uuid4()).replace("-", "")
+
+
+def generate_64bit():
+    return generate_128bit()[:32]
+
+
+def timestamp():
+    return str(time.time()).replace(".", "")
+
+
+TRACING = config.tracing
+TRACING_DISABLED = not TRACING.enabled
+
+
+class Tracer:
+    def gen_id(self):
+        if TRACING.trace_id_128bit:
+            trace_id = generate_128bit()
+        else:
+            trace_id = generate_64bit()
+        _trace_id_ctx_var.set(trace_id)
+        return trace_id
+
+    def __init__(self, span_name):
+        if TRACING_DISABLED:
+            return
+        span_id = get_span_id()
+        self.parent_span_id = None
+        if span_id != "":
+            # We are already inside a trace context
+            self.parent_span_id = span_id
+        self.trace_id = get_trace_id()
+        self.span_id = self.gen_id()
+        self.span_name = span_name
+
+    def __enter__(self):
+        if TRACING_DISABLED:
+            return nullcontext()
+        self.trace = {
+            "traceId": self.trace_id,
+            "id": self.span_id,
+            "name": self.span_name,
+            "timestamp": time.time(),
+            "tags": TRACING.tags,
+        }
+        if self.parent_span_id:
+            self.trace["parent_span_id"] = self.parent_span_id
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if TRACING_DISABLED:
+            return
+        self.trace["duration"] = time.time() - self.trace["timestamp"]
+        self.submit()
+
+    def submit(self):
+        print(f"{self.span_name}: {self.trace['duration']}")
+        try:
+            url = f"{TRACING.collector}{TRACING.endpoint}"
+            requests.post(url, json=self.trace)
+        # pylint: disable=broad-except
+        except Exception as e:
+            print(f"Failed to submit trace: {self.trace}, Error:{e}")

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/views/discovery.py

@@ -117,21 +117,24 @@ async def perform_discovery(
         authenticate(req)
     if discovery_cache.enabled:
         logs.access_logger.queue_log_fields(CACHE_XDS_HIT=False)
-        cache_key = compute_hash(
-            [
-                api_version,
-                resource_type,
-                req.envoy_version,
-                req.resource_names,
-                req.desired_controlplane,
-                req.hide_private_keys,
-                req.type_url,
-                req.node.cluster,
-                req.node.locality,
-                req.node.metadata.get("auth", None),
-                req.node.metadata.get("num_cpus", None),
-            ]
-        )
+        metadata_keys = discovery_cache.extra_keys.get("metadata", [])
+        extra_metadata = [req.node.metadata.get(key, None) for key in metadata_keys]
+        hash_keys = [
+            api_version,
+            resource_type,
+            req.envoy_version,
+            req.resource_names,
+            req.desired_controlplane,
+            req.hide_private_keys,
+            req.type_url,
+            req.node.cluster,
+            req.node.locality,
+            req.node.metadata.get("auth", None),
+            req.node.metadata.get("num_cpus", None),
+        ] + extra_metadata
+
+        cache_key = compute_hash(hash_keys)
+
         if template := await cache.get(key=cache_key, default=None):
             logs.access_logger.queue_log_fields(CACHE_XDS_HIT=True)
             return template  # type: ignore[no-any-return]

{sovereign-0.27.0 → sovereign-0.29.0}/src/sovereign/views/interface.py

@@ -103,8 +103,8 @@ async def resources(
             resource_type=xds_type,
             skip_auth=True,
         )
-    except KeyError:
-        ret["resources"] = []
+    except KeyError as e:
+        ret["resources"] = [{"sovereign_error": str(e)}]
     else:
         ret["resources"] += response.deserialize_resources()
     return html_templates.TemplateResponse(

sovereign-0.27.0/src/sovereign/config_loader.py

@@ -1,222 +0,0 @@
-import os
-import json
-from enum import Enum
-from typing import Any, Dict, Callable, Union, Protocol
-from types import ModuleType
-import yaml
-import jinja2
-import requests
-import importlib
-from importlib.machinery import SourceFileLoader
-from pathlib import Path
-from pydantic import BaseModel
-from sovereign.utils.resources import get_package_file_bytes
-
-
-class Serialization(Enum):
-    """
-    Types of deserialization available in Sovereign
-    for loading configuration field values.
-    """
-
-    yaml = "yaml"
-    json = "json"
-    orjson = "orjson"
-    ujson = "ujson"
-    jinja = "jinja"
-    jinja2 = "jinja2"
-    string = "string"
-    raw = "raw"
-    skip = "skip"
-
-
-jinja_env = jinja2.Environment(autoescape=True)
-
-
-def passthrough(item: Any) -> Any:
-    return item
-
-
-def string(item: Any) -> Any:
-    return str(item)
-
-
-serializers: Dict[Serialization, Callable[[Any], Any]] = {
-    Serialization.yaml: yaml.safe_load,
-    Serialization.json: json.loads,
-    Serialization.jinja: jinja_env.from_string,
-    Serialization.jinja2: jinja_env.from_string,
-    Serialization.string: string,
-    Serialization.raw: passthrough,
-}
-
-
-try:
-    import ujson
-
-    serializers[Serialization.ujson] = ujson.loads
-    jinja_env.policies["json.dumps_function"] = ujson.dumps
-except ImportError:
-    # This lambda will raise an exception when the serializer is used; otherwise we should not crash
-    serializers[Serialization.ujson] = lambda *a, **kw: raise_(
-        ImportError("ujson must be installed to use in config_loaders")
-    )
-
-try:
-    import orjson
-
-    serializers[Serialization.orjson] = orjson.loads
-
-    # orjson.dumps returns bytes, so we have to wrap & decode it
-    def orjson_dumps(*args: Any, **kwargs: Any) -> Any:
-        try:
-            representation = orjson.dumps(*args, **kwargs)
-        except TypeError:
-            raise TypeError(f"Unable to dump objects using ORJSON: {args}, {kwargs}")
-        try:
-            return representation.decode()
-        except Exception as e:
-            raise e.__class__(
-                f"Unable to decode ORJSON: {representation!r}. Original exception: {e}"
-            )
-
-    jinja_env.policies["json.dumps_function"] = orjson_dumps
-    jinja_env.policies["json.dumps_kwargs"] = {"option": orjson.OPT_SORT_KEYS}
-except ImportError:
-    # This lambda will raise an exception when the serializer is used; otherwise we should not crash
-    serializers[Serialization.orjson] = lambda *a, **kw: raise_(
-        ImportError("orjson must be installed to use in config_loaders")
-    )
-
-try:
-    import boto3
-except ImportError:
-    boto3 = None
-
-
-class CustomLoader(Protocol):
-    def load(self, path: str, ser: Serialization) -> Any:
-        ...
-
-
-class Loadable(BaseModel):
-    protocol: str = "http"
-    serialization: Serialization = Serialization.yaml
-    path: str
-
-    def load(self, default: Any = None) -> Any:
-        try:
-            return loaders[self.protocol](self.path, self.serialization)
-        except Exception:
-            if default is not None:
-                return default
-            raise
-
-    @staticmethod
-    def from_legacy_fmt(fmt_string: str) -> "Loadable":
-        if "://" not in fmt_string:
-            return Loadable(
-                protocol="inline", serialization=Serialization.string, path=fmt_string
-            )
-        try:
-            scheme, path = fmt_string.split("://")
-        except ValueError:
-            raise ValueError(fmt_string)
-        try:
-            proto, ser = scheme.split("+")
-        except ValueError:
-            proto, ser = scheme, "yaml"
-
-        serialization: Serialization = Serialization(ser)
-        if proto in ("python", "module"):
-            serialization = Serialization.raw
-        if proto in ("http", "https"):
-            path = "://".join([proto, path])
-
-        return Loadable(
-            protocol=proto,
-            serialization=serialization,
-            path=path,
-        )
-
-
-def raise_(e: Exception) -> Exception:
-    raise e
-
-
-def load_file(path: str, ser: Serialization) -> Any:
-    with open(path) as f:
-        contents = f.read()
-        try:
-            return serializers[ser](contents)
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Unable to load {path}")
-
-
-def load_package_data(path: str, ser: Serialization) -> Any:
-    pkg, pkg_file = path.split(":")
-    data = get_package_file_bytes(pkg, pkg_file)
-    return serializers[ser](data)
-
-
-def load_http(path: str, ser: Serialization) -> Any:
-    response = requests.get(path)
-    response.raise_for_status()
-    data = response.text
-    return serializers[ser](data)
-
-
-def load_env(variable: str, ser: Serialization = Serialization.raw) -> Any:
-    data = os.getenv(variable)
-    try:
-        return serializers[ser](data)
-    except AttributeError as e:
-        raise AttributeError(
-            f"Unable to read environment variable {variable}: {repr(e)}"
-        )
-
-
-def load_module(name: str, _: Serialization = Serialization.raw) -> Any:
-    if ":" in name:
-        mod, fn = name.rsplit(":", maxsplit=1)
-    else:
-        mod, fn = name, ""
-    imported = importlib.import_module(mod)
-    if fn != "":
-        return getattr(imported, fn)
-    return imported
-
-
-def load_s3(path: str, ser: Serialization = Serialization.raw) -> Any:
-    if isinstance(boto3, type(None)):
-        raise ImportError(
-            "boto3 must be installed to load S3 paths. Use ``pip install sovereign[boto]``"
-        )
-    bucket, key = path.split("/", maxsplit=1)
-    s3 = boto3.client("s3")
-    response = s3.get_object(Bucket=bucket, Key=key)
-    data = "".join([chunk.decode() for chunk in response["Body"]])
-    return serializers[ser](data)
-
-
-def load_python(path: str, _: Serialization = Serialization.raw) -> ModuleType:
-    p = str(Path(path).absolute())
-    loader = SourceFileLoader(p, path=p)
-    return loader.load_module(p)
-
-
-def load_inline(path: str, _: Serialization = Serialization.raw) -> Any:
-    return str(path)
-
-
-loaders: Dict[str, Callable[[str, Serialization], Union[str, Any]]] = {
-    "file": load_file,
-    "pkgdata": load_package_data,
-    "http": load_http,
-    "https": load_http,
-    "env": load_env,
-    "module": load_module,
-    "s3": load_s3,
-    "python": load_python,
-    "inline": load_inline,
-}

sovereign-0.27.0/src/sovereign/testing/loaders.py

@@ -1,9 +0,0 @@
-from typing import Any
-from sovereign.config_loader import CustomLoader, Serialization
-
-
-class Multiply(CustomLoader):
-    @staticmethod
-    def load(path: str, ser: Serialization) -> Any:
-        result = path * 2
-        return f"{ser}:{result}"