warpzone-sdk 15.0.0.dev7__tar.gz → 15.0.0.dev9__tar.gz

{warpzone_sdk-15.0.0.dev7 → warpzone_sdk-15.0.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warpzone-sdk
-Version: 15.0.0.dev7
+Version: 15.0.0.dev9
 Summary: The main objective of this package is to centralize logic used to interact with Azure Functions, Azure Service Bus and Azure Table Storage
 Author: Team Enigma
 Author-email: enigma@energinet.dk

{warpzone_sdk-15.0.0.dev7 → warpzone_sdk-15.0.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "warpzone-sdk"
-version = "15.0.0.dev7"
+version = "15.0.0.dev9"
 description = "The main objective of this package is to centralize logic used to interact with Azure Functions, Azure Service Bus and Azure Table Storage"
 authors = [{ name = "Team Enigma", email = "enigma@energinet.dk" }]
 requires-python = ">=3.10"

warpzone_sdk-15.0.0.dev9/warpzone/function/monitor.py

@@ -0,0 +1,57 @@
+import inspect
+from contextlib import contextmanager
+from typing import Callable
+
+import azure.functions as func
+
+from warpzone.function.types import SingleArgumentCallable
+from warpzone.monitor import traces
+
+# Configure tracing at import time (once per worker process)
+traces.configure_tracing()
+
+SUBJECT_IDENTIFIER = "<Subject>"
+
+
+@contextmanager
+def run_in_trace_context(context: func.Context):
+    trace_context = context.trace_context
+    with traces.set_trace_context(
+        trace_context.trace_parent, trace_context.trace_state
+    ):
+        yield
+
+
+def monitor(main: SingleArgumentCallable) -> Callable:
+    """Wrap Azure function with logging and tracing
+    configured for monitoring in App Insights.
+
+    Args:
+        f (SingleArgumentCallable): Azure function to be wrapped
+
+    Returns:
+        Callable: Azure function with
+            - argument
+                name: "arg"
+                description: argument of the original function
+            - argument
+                name: "context"
+                description: Azure function context
+            - return value
+                description: return value of original function
+    """
+
+    async def wrapper_async(arg, context: func.Context):
+        with run_in_trace_context(context):
+            result = await main(arg)
+            return result
+
+    def wrapper(arg, context: func.Context):
+        with run_in_trace_context(context):
+            result = main(arg)
+            return result
+
+    if inspect.iscoroutinefunction(main):
+        return wrapper_async
+    else:
+        return wrapper

warpzone_sdk-15.0.0.dev9/warpzone/monitor/traces.py

@@ -0,0 +1,142 @@
+import logging
+import os
+from contextlib import contextmanager
+
+from azure.core.settings import settings
+from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
+from opentelemetry import context, trace
+from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+from opentelemetry.sdk.trace import ReadableSpan, SpanProcessor, TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.sampling import ALWAYS_ON
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+
+# Enable OpenTelemetry tracing for Azure SDK (including Service Bus)
+# This must be set before any Azure SDK clients are created
+settings.tracing_implementation = "opentelemetry"
+
+logger = logging.getLogger(__name__)
+
+_TRACING_IS_CONFIGURED = False
+
+# Span name prefixes to allow from Azure SDK (Service Bus for function chaining)
+_ALLOWED_AZURE_SPAN_NAMES = frozenset({"ServiceBus.message"})
+
+
+class AzureSDKTraceFilter(SpanProcessor):
+    """SpanProcessor that filters out noisy Azure SDK traces.
+
+    Allows:
+    - All non-Azure SDK spans (custom/user traces)
+    - Service Bus spans (for tracing function chains)
+
+    Drops:
+    - Other Azure SDK spans (HTTP client, blob storage, etc.)
+    """
+
+    def __init__(self, wrapped_processor: SpanProcessor):
+        self.wrapped_processor = wrapped_processor
+
+    def on_start(
+        self, span: ReadableSpan, parent_context: context.Context = None
+    ) -> None:
+        self.wrapped_processor.on_start(span, parent_context)
+
+    def on_end(self, span: ReadableSpan) -> None:
+        scope = span.instrumentation_scope
+        if scope and scope.name:
+            # Check if it's an Azure SDK span (uses azure.core.tracing wrapper)
+            if scope.name.startswith("azure."):
+                # Allow only specific Service Bus span names
+                span_name = getattr(span, "name", "") or ""
+                if span_name in _ALLOWED_AZURE_SPAN_NAMES:
+                    self.wrapped_processor.on_end(span)
+                # Drop other Azure SDK spans
+                return
+
+        # Pass through: non-Azure SDK spans (custom traces)
+        self.wrapped_processor.on_end(span)
+
+    def shutdown(self) -> None:
+        self.wrapped_processor.shutdown()
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return self.wrapped_processor.force_flush(timeout_millis)
+
+
+def configure_tracing():
+    """Configure OpenTelemetry tracing with Azure Monitor exporter.
+
+    This sets up tracing for Service Bus and custom spans.
+    Other Azure SDK traces (HTTP, blob, etc.) are filtered out.
+
+    Should be called once before any tracing is performed.
+    """
+    global _TRACING_IS_CONFIGURED
+    if _TRACING_IS_CONFIGURED:
+        return
+
+    # Set up tracer provider with Azure Function resource info
+    resource = Resource.create({SERVICE_NAME: os.getenv("WEBSITE_SITE_NAME")})
+    provider = TracerProvider(
+        sampler=ALWAYS_ON,
+        resource=resource,
+    )
+    trace.set_tracer_provider(provider)
+
+    # Set up Azure Monitor trace exporter with filter
+    try:
+        trace_exporter = AzureMonitorTraceExporter()
+        span_processor = BatchSpanProcessor(trace_exporter)
+        filtered_processor = AzureSDKTraceFilter(span_processor)
+        provider.add_span_processor(filtered_processor)
+    except ValueError:
+        logger.warning(
+            "Cannot set up tracing to App Insights, as no instrumentation key is set."
+        )
+
+    _TRACING_IS_CONFIGURED = True
+
+
+@contextmanager
+def set_trace_context(trace_parent: str, trace_state: str = ""):
+    """Context manager for setting the trace context.
+
+    Args:
+        trace_parent (str): Trace parent ID
+        trace_state (str, optional): Trace state. Defaults to "".
+    """
+    carrier = {"traceparent": trace_parent, "tracestate": trace_state}
+    ctx = TraceContextTextMapPropagator().extract(carrier=carrier)
+
+    token = context.attach(ctx)
+    try:
+        yield
+    finally:
+        context.detach(token)
+
+
+def get_tracer(name: str):
+    tracer = trace.get_tracer(name)
+    return tracer
+
+
+def get_current_diagnostic_id() -> str:
+    """Gets diagnostic id from current span
+
+    The diagnostic id is a concatenation of operation-id and parent-id
+
+    Returns:
+        str: diagnostic id
+    """
+    span = trace.get_current_span()
+
+    if not span.is_recording():
+        return ""
+
+    operation_id = "{:016x}".format(span.context.trace_id)
+    parent_id = "{:016x}".format(span.context.span_id)
+
+    diagnostic_id = f"00-{operation_id}-{parent_id}-01"
+
+    return diagnostic_id

warpzone_sdk-15.0.0.dev7/warpzone/function/monitor.py

@@ -1,93 +0,0 @@
-import inspect
-import threading
-from contextlib import contextmanager
-from typing import Callable
-
-import azure.functions as func
-from azure.monitor.opentelemetry import configure_azure_monitor
-from opentelemetry import trace
-
-from warpzone.function.types import SingleArgumentCallable
-from warpzone.monitor import traces
-
-# Thread-safe lazy initialization of Azure Monitor
-_azure_monitor_configured = False
-_azure_monitor_lock = threading.Lock()
-
-
-def _ensure_azure_monitor_configured():
-    """Ensure Azure Monitor is configured exactly once, thread-safely."""
-    global _azure_monitor_configured
-    if _azure_monitor_configured:
-        return
-
-    with _azure_monitor_lock:
-        # Double-check after acquiring lock
-        if _azure_monitor_configured:
-            return
-
-        # Disable OpenTelemetry logging instrumentation - let Azure Functions
-        # handle log correlation via its native thread-local storage mechanism.
-        # This prevents conflicts between OpenTelemetry's context-based correlation
-        # and Azure Functions' invocation_id-based correlation which can cause
-        # logs to leak between concurrent function invocations.
-        configure_azure_monitor(
-            disable_logging=True,
-        )
-
-        # Apply trace filtering to suppress all Azure SDK traces except Service Bus
-        tracer_provider = trace.get_tracer_provider()
-        if hasattr(tracer_provider, "_active_span_processor"):
-            original_processor = tracer_provider._active_span_processor
-            filtered_processor = traces.AzureSDKTraceFilter(original_processor)
-            tracer_provider._active_span_processor = filtered_processor
-
-        _azure_monitor_configured = True
-
-
-SUBJECT_IDENTIFIER = "<Subject>"
-
-
-@contextmanager
-def run_in_trace_context(context: func.Context):
-    trace_context = context.trace_context
-    span_name = context.function_name or "azure_function"
-    with traces.set_trace_context(trace_context.trace_parent, span_name=span_name):
-        yield
-
-
-def monitor(main: SingleArgumentCallable) -> Callable:
-    """Wrap Azure function with logging and tracing
-    configured for monitoring in App Insights.
-
-    Args:
-        f (SingleArgumentCallable): Azure function to be wrapped
-
-    Returns:
-        Callable: Azure function with
-            - argument
-                name: "arg"
-                description: argument of the original function
-            - argument
-                name: "context"
-                description: Azure function context
-            - return value
-                description: return value of original function
-    """
-    # Ensure Azure Monitor is configured before any function runs
-    _ensure_azure_monitor_configured()
-
-    async def wrapper_async(arg, context: func.Context):
-        with run_in_trace_context(context):
-            result = await main(arg)
-            return result
-
-    def wrapper(arg, context: func.Context):
-        with run_in_trace_context(context):
-            result = main(arg)
-            return result
-
-    if inspect.iscoroutinefunction(main):
-        return wrapper_async
-    else:
-        return wrapper

warpzone_sdk-15.0.0.dev7/warpzone/monitor/traces.py

@@ -1,112 +0,0 @@
-from contextlib import contextmanager
-
-from azure.core.settings import settings
-from opentelemetry import context, trace
-from opentelemetry.sdk.trace import ReadableSpan, SpanProcessor
-from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-
-settings.tracing_implementation = "opentelemetry"
-
-
-class AzureSDKTraceFilter(SpanProcessor):
-    """Custom SpanProcessor to filter out Azure SDK traces except Service Bus.
-
-    It drops spans from Azure SDK libraries except Service Bus messages,
-    preventing them from being exported to Azure Monitor.
-    """
-
-    def __init__(self, wrapped_processor: SpanProcessor):
-        """Initialize with the actual processor to wrap.
-
-        Args:
-            wrapped_processor: The underlying processor (e.g., BatchSpanProcessor)
-        """
-        self.wrapped_processor = wrapped_processor
-
-    def on_start(
-        self, span: ReadableSpan, parent_context: context.Context = None
-    ) -> None:
-        """Called when a span is started."""
-        self.wrapped_processor.on_start(span, parent_context)
-
-    def on_end(self, span: ReadableSpan) -> None:
-        """Called when a span is ended. Filter based on span attributes."""
-        # Safely get span name, handling None or mock objects
-        span_name = getattr(span, "name", None)
-        if span_name is None or not isinstance(span_name, str):
-            # Pass through spans without valid names (e.g., in test mocks)
-            self.wrapped_processor.on_end(span)
-            return
-
-        # Check if service bus span - always allow
-        if "servicebus.message" in span_name.lower():
-            self.wrapped_processor.on_end(span)
-            return
-
-        # Check if this is an Azure SDK span we want to suppress
-        instrumentation_scope = span.instrumentation_scope
-        if instrumentation_scope and instrumentation_scope.name:
-            # Suppress spans from Azure SDK libraries
-            if instrumentation_scope.name.startswith("azure."):
-                return  # Drop this span
-
-        # Pass through all other spans
-        self.wrapped_processor.on_end(span)
-
-    def shutdown(self) -> None:
-        """Shutdown the wrapped processor."""
-        self.wrapped_processor.shutdown()
-
-    def force_flush(self, timeout_millis: int = 30000) -> bool:
-        """Force flush the wrapped processor."""
-        return self.wrapped_processor.force_flush(timeout_millis)
-
-
-@contextmanager
-def set_trace_context(trace_parent: str, span_name: str = "function_execution"):
-    """Context manager for setting the trace context.
-
-    Attaches the propagated trace context and creates a child span for tracing.
-    Note: Log correlation is handled by Azure Functions' native mechanism,
-    not OpenTelemetry, so this primarily affects span/dependency tracking.
-
-    Args:
-        trace_parent (str): Trace parent ID from the incoming request
-        span_name (str): Name for the span. Defaults to "function_execution".
-    """
-    carrier = {"traceparent": trace_parent}
-    ctx = TraceContextTextMapPropagator().extract(carrier=carrier)
-
-    token = context.attach(ctx)
-    try:
-        tracer = trace.get_tracer(__name__)
-        with tracer.start_as_current_span(span_name):
-            yield
-    finally:
-        context.detach(token)
-
-
-def get_tracer(name: str):
-    tracer = trace.get_tracer(name)
-    return tracer
-
-
-def get_current_diagnostic_id() -> str:
-    """Gets diagnostic id from current span
-
-    The diagnostic id is a concatenation of operation-id and parent-id
-
-    Returns:
-        str: diagnostic id
-    """
-    span = trace.get_current_span()
-
-    if not span.is_recording():
-        return ""
-
-    operation_id = "{:016x}".format(span.context.trace_id)
-    parent_id = "{:016x}".format(span.context.span_id)
-
-    diagnostic_id = f"00-{operation_id}-{parent_id}-01"
-
-    return diagnostic_id