odigos-opentelemetry-python 1.0.80__tar.gz → 1.0.81__tar.gz

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odigos-opentelemetry-python
-Version: 1.0.80
+Version: 1.0.81
 Summary: Odigos Initializer for Python OpenTelemetry Components
 Author-email: odigos-io <support@odigos.io>
 Requires-Python: >=3.9

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.81}/initializer/odigos_sampler.py

@@ -1,34 +1,55 @@
+import logging
+from threading import Lock
+from typing import Any, Mapping, Optional, Sequence
+
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace.sampling import Decision, Sampler, SamplingResult, _get_parent_trace_state
 from opentelemetry.semconv.attributes import http_attributes as http_attributes_semconv
 from opentelemetry.semconv.attributes import server_attributes as server_attributes_semconv
-from opentelemetry.sdk.trace.sampling import Sampler, Decision, SamplingResult, _get_parent_trace_state
-from threading import Lock
-import logging
+from opentelemetry.trace import Link, SpanKind, TraceState
+from opentelemetry.util.types import Attributes
 
+from initializer.schemas.sampling import (
+    HeadSamplingConfig,
+    HeadSamplingHttpClientOperationMatcher,
+    HeadSamplingHttpServerOperationMatcher,
+    HeadSamplingOperationMatcher,
+    NoisyOperation,
+)
 
 # Setup the Sampler logger
 sampler_logger = logging.getLogger('odigos')
 
-class OdigosSampler(Sampler):
 
+class OdigosSampler(Sampler):
     # For compatibility with 64 bit trace IDs, the sampler checks the 64
     # low-order bits of the trace ID to decide whether to sample a given trace.
     TRACE_ID_LIMIT = (1 << 64) - 1
 
     def __init__(self):
         self._lock = Lock()
-        self._config = None
+        self._config: Optional[HeadSamplingConfig] = None
 
     def _trace_id_based_sampling(self, trace_id: int, percentage_to_sample: float) -> bool:
         """Mimic OpenTelemetry's trace ID-based sampling logic with 64-bit range."""
         # Since percentage to sample is in percents and we need a fraction, divide by 100
         fraction = percentage_to_sample / 100
-        
+
         # Calculate the bound based on the fraction using OpenTelemetry's approach
         bound = round(fraction * (self.TRACE_ID_LIMIT + 1))
         # Apply the TRACE_ID_LIMIT mask to ensure 64-bit range and compare it to the bound
         return (trace_id & self.TRACE_ID_LIMIT) < bound
 
-    def should_sample(self, parent_context, trace_id, name, kind, attributes, links):
+    def should_sample(
+        self,
+        parent_context: Optional[Context],
+        trace_id: int,
+        name: str,
+        kind: Optional[SpanKind] = None,
+        attributes: Attributes = None,
+        links: Optional[Sequence["Link"]] = None,
+        trace_state: Optional[TraceState] = None,
+    ) -> "SamplingResult":
         attributes = attributes or {}
         with self._lock:
             # sampler_logger.debug(f'Running Should_sample a span with the following attributes: {attributes}')
@@ -37,49 +58,64 @@ class OdigosSampler(Sampler):
                 # sampler_logger.debug('No configuration is set, returning RECORD_AND_SAMPLE')
                 return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=_get_parent_trace_state(parent_context))
 
-            noisy_operations = self._config.get('noisyOperations', [])
-            lowest_percentage = None
+            is_dry_run: bool = self._config.get('dryRun', False)
+            noisy_operations: list[NoisyOperation] = self._config.get('noisyOperations', [])
+            # Track the rule with the lowest percentageAtMost so the tracestate entry reports the actual deciding rule's id (first-wins on ties)
+            winning_operation: Optional[NoisyOperation] = None
 
             for noisy_operation in noisy_operations:
                 if noisy_operation.get("disabled"):
                     continue
 
-                percentage_to_sample = noisy_operation.get("percentageAtMost", 0.0)
+                percentage_to_sample: float = noisy_operation.get("percentageAtMost", 0.0)
 
-                http_operation_sample = noisy_operation.get("operation")
-                if not http_operation_sample:
-                    continue
+                http_operation_sample: Optional[HeadSamplingOperationMatcher] = noisy_operation.get("operation")
 
                 # sampler_logger.debug(f'Evaluating noisy operation: {noisy_operation}')
 
-                matched = False
-            
-                if http_server_sample := http_operation_sample.get("httpServer"):
-                    matched = self._match_http_server_sample_rule(http_server_sample, attributes) or matched
+                # No operation matcher -> rule applies workload-wide (matches every span)
+                # This supports Sampling rules that scope by sourceScopes (workload) without specific HTTP matcher
+                if not http_operation_sample:
+                    matched = True
+                else:  # When we have a granular operation, check it vs the server/client rules specified in the noisy operation
+                    matched = False
+                    if http_server_sample := http_operation_sample.get("httpServer"):
+                        matched = self._match_http_server_sample_rule(http_server_sample, attributes) or matched
 
-                if http_client_sample := http_operation_sample.get("httpClient"):
-                    matched = self._match_http_client_sample_rule(http_client_sample, attributes) or matched
+                    if http_client_sample := http_operation_sample.get("httpClient"):
+                        matched = self._match_http_client_sample_rule(http_client_sample, attributes) or matched
 
                 # sampler_logger.debug(f'Noisy operation matched: {matched}, percentage: {percentage_to_sample}')
-                if matched:  # For matched operations, compute the minimal lowest percentage
-                    if lowest_percentage is None:
-                        lowest_percentage = percentage_to_sample
-                    else:
-                        lowest_percentage = min(lowest_percentage, percentage_to_sample)
-
-            if lowest_percentage is not None:
-                if self._trace_id_based_sampling(trace_id, lowest_percentage):
+                if matched and (winning_operation is None or percentage_to_sample < winning_operation.get("percentageAtMost", 0.0)):
+                    winning_operation = noisy_operation
+
+            if winning_operation is not None:
+                # Build tracestate from the winning rule and attach it to both decisions.
+                # Even on DROP the SpanContext (and its trace_state) is propagated to downstream services via the tracestate header,
+                # enabling consistent head-sampling and tail-sampler decisions across the trace.
+                lowest_percentage = winning_operation.get("percentageAtMost", 0.0)
+                sampled = self._trace_id_based_sampling(trace_id, lowest_percentage)
+
+                dry_run_sampled = sampled if is_dry_run else None
+                trace_state = self.build_tracestate(parent_context, winning_operation, dry_run_sampled)
+
+                # In dry-run mode, never actually drop spans
+                if is_dry_run:
+                    # sampler_logger.debug(f'Dry run [{trace_id}] would_be_sampled={sampled} (lowest_percentage={lowest_percentage})')
+                    return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=trace_state)
+
+                if sampled:
                     # sampler_logger.debug(f'Trace [{trace_id}] is sampled with lowest percentage {lowest_percentage}')
-                    return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=_get_parent_trace_state(parent_context))
+                    return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=trace_state)
                 else:
                     # sampler_logger.debug(f'Trace [{trace_id}] is dropped with lowest percentage {lowest_percentage}')
-                    return SamplingResult(Decision.DROP)
+                    return SamplingResult(Decision.DROP, trace_state=trace_state)
 
-            # sampler_logger.debug(f'No noisy operation matched, sampling the trace')
+            # sampler_logger.debug('No noisy operation matched, sampling the trace')
             return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=_get_parent_trace_state(parent_context))
 
     @staticmethod
-    def _get_attribute(span_attributes: dict[str, str], *keys: str):
+    def _get_attribute(span_attributes: Mapping[str, Any], *keys: str):
         """Return the first non-None value found for the given attribute keys."""
         for key in keys:
             value = span_attributes.get(key)
@@ -87,7 +123,7 @@ class OdigosSampler(Sampler):
                 return value
         return None
 
-    def _match_http_server_sample_rule(self, http_server_rule: dict[str, str], span_attributes: dict[str, str]) -> bool:
+    def _match_http_server_sample_rule(self, http_server_rule: HeadSamplingHttpServerOperationMatcher, span_attributes: Mapping[str, Any]) -> bool:
         """
         Try to match all the http server's attributes to the definitions of the noisy action
         """
@@ -106,7 +142,7 @@ class OdigosSampler(Sampler):
             # If we have target, try to match it with the route in the sampling rule
             if target:
                 return self._match_rule_route_to_span(http_server_rule["route"], target)
-                
+
         if http_server_rule.get("routePrefix") and not (span_route or "").startswith(http_server_rule["routePrefix"]):
             return False
         if http_server_rule.get("method") and http_server_rule["method"] != span_method:
@@ -114,7 +150,7 @@ class OdigosSampler(Sampler):
 
         return True
 
-    def _match_http_client_sample_rule(self, http_client_rule: dict[str, str], span_attributes: dict[str, str]) -> bool:
+    def _match_http_client_sample_rule(self, http_client_rule: HeadSamplingHttpClientOperationMatcher, span_attributes: Mapping[str, Any]) -> bool:
         """
         Try to match all the http client's attributes to the definitions of the noisy action
         """
@@ -158,7 +194,6 @@ class OdigosSampler(Sampler):
 
         return True
 
-
     def get_description(self):
         return "OdigosSampler"
 
@@ -166,3 +201,24 @@ class OdigosSampler(Sampler):
         with self._lock:
             # sampler_logger.debug(f'Updating the configuration with the new configuration: {new_config}')
             self._config = new_config
+
+    def build_tracestate(
+        self,
+        parent_context: Optional[Context],
+        noisy_operation: NoisyOperation,
+        dry_run_sampled: Optional[bool] = None,
+    ) -> TraceState:
+        tracestate = _get_parent_trace_state(parent_context)
+
+        if not tracestate:
+            tracestate = TraceState()
+
+        # Round percentage to 2 decimal places for byte-identical tracestate values
+        percentage = round(noisy_operation.get("percentageAtMost", 0.0), 2)
+        noisy_op_tracestate_value = f"c:n;dr.p:{percentage};dr.id:{noisy_operation['id']}"
+
+        if dry_run_sampled is not None:
+            noisy_op_tracestate_value += ";dry:t" if dry_run_sampled else ";dry:f"
+        tracestate = tracestate.add("odigos", noisy_op_tracestate_value)
+
+        return tracestate

odigos_opentelemetry_python-1.0.81/initializer/schemas/sampling.py

@@ -0,0 +1,39 @@
+"""Typed shapes for the head-sampling configuration sent by the Odigos OpAMP server.
+
+Mirrors the Go schema in odigos/common/api/sampling (matchers_head.go, sampling.go).
+All fields are `omitempty` on the Go side (except NoisyOperation.id), so every
+key is treated as optional on the wire — hence `total=False` on every TypedDict.
+"""
+
+from typing import TypedDict
+
+
+class HeadSamplingHttpServerOperationMatcher(TypedDict, total=False):
+    route: str
+    routePrefix: str
+    method: str
+
+
+class HeadSamplingHttpClientOperationMatcher(TypedDict, total=False):
+    serverAddress: str
+    templatedPath: str
+    templatedPathPrefix: str
+    method: str
+
+
+class HeadSamplingOperationMatcher(TypedDict, total=False):
+    httpServer: HeadSamplingHttpServerOperationMatcher
+    httpClient: HeadSamplingHttpClientOperationMatcher
+
+
+class NoisyOperation(TypedDict, total=False):
+    id: str
+    name: str
+    disabled: bool
+    operation: HeadSamplingOperationMatcher
+    percentageAtMost: float
+
+
+class HeadSamplingConfig(TypedDict, total=False):
+    dryRun: bool
+    noisyOperations: list[NoisyOperation]

odigos_opentelemetry_python-1.0.81/initializer/version.py

@@ -0,0 +1 @@
+VERSION = "1.0.81"

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.81}/odigos_opentelemetry_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odigos-opentelemetry-python
-Version: 1.0.80
+Version: 1.0.81
 Summary: Odigos Initializer for Python OpenTelemetry Components
 Author-email: odigos-io <support@odigos.io>
 Requires-Python: >=3.9

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.81}/odigos_opentelemetry_python.egg-info/SOURCES.txt

@@ -13,6 +13,8 @@ initializer/version.py
 initializer/distro/__init__.py
 initializer/distro/distro.py
 initializer/distro/instrumentation_registry.py
+initializer/schemas/__init__.py
+initializer/schemas/sampling.py
 odigos_opentelemetry_python.egg-info/PKG-INFO
 odigos_opentelemetry_python.egg-info/SOURCES.txt
 odigos_opentelemetry_python.egg-info/dependency_links.txt

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.81}/opamp/http_client.py

@@ -147,8 +147,8 @@ class OpAMPHTTPClient:
                                     # The default config is preloaded when the EBPFSpanProcessor is initialized
                                     pass
 
-                        sdk_config = utils.get_sdk_config(first_message_server_to_agent.remote_config.config.config_map)
-                        self.signals = utils.parse_first_message_signals(sdk_config)
+                        container_config = utils.get_container_config(first_message_server_to_agent.remote_config.config.config_map)
+                        self.signals = utils.parse_first_message_signals(container_config)
 
                         # Store initial sampler config for direct access
                         remote_config = self.get_remote_config(first_message_server_to_agent)

odigos_opentelemetry_python-1.0.81/opamp/utils.py

@@ -0,0 +1,26 @@
+import json
+
+def get_container_config(config_map):
+    """
+    Extracts and parses the container configuration from the config map.
+    """
+    if "container_config" not in config_map:
+        return {}
+
+    try:
+        return json.loads(config_map["container_config"].body)
+    except json.JSONDecodeError:
+        return {}
+
+
+def parse_first_message_signals(container_config): # type: ignore
+    """
+    Parses the trace, logs, and metrics signals from the container config.
+    Signal is considered enabled if its key exists in the config.
+    """
+
+    return {
+        "traceSignal": "traces" in container_config,
+        "metricsSignal": "metrics" in container_config,
+        "logsSignal": "logs" in container_config,
+    }

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.81}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "odigos-opentelemetry-python"
-version = "1.0.80"
+version = "1.0.81"
 description = "Odigos Initializer for Python OpenTelemetry Components"
 requires-python = ">=3.9"
 authors = [
@@ -92,6 +92,13 @@ test = [
     "pytest >= 8.0",
 ]
 
+[dependency-groups]
+dev = [
+    "ruff >= 0.15.12",
+    "ty >= 0.0.33",
+    "pre-commit >= 3.5.0",
+]
+
 [project.entry-points.opentelemetry_post_instrument]
 odigos_post = "initializer.post_instrument:run_post_hook"
 
@@ -122,3 +129,33 @@ include = [
     "opentelemetry",
     "opentelemetry.*",
 ]
+
+[tool.ruff]
+line-length = 150
+target-version = "py39"
+extend-exclude = [
+    ".venv",
+    "dist",
+    "build",
+    "*.egg-info",
+    "tests/integration/configurator",
+]
+
+[tool.ruff.lint]
+# Default rule set: pycodestyle errors (E) + pyflakes (F).
+select = ["E", "F"]
+
+[tool.ruff.format]
+quote-style = "preserve"
+indent-style = "space"
+
+[tool.ty.environment]
+python-version = "3.9"
+
+[tool.ty.src]
+exclude = [
+    ".venv",
+    "dist",
+    "build",
+    "tests/integration/configurator",
+]

odigos_opentelemetry_python-1.0.80/initializer/version.py

@@ -1 +0,0 @@
-VERSION = "1.0.80"

odigos_opentelemetry_python-1.0.80/opamp/utils.py

@@ -1,26 +0,0 @@
-import json
-
-def get_sdk_config(config_map):
-    """
-    Extracts and parses the SDK configuration from the config map.
-    """
-    if "SDK" not in config_map:
-        return {}
-
-    try:
-        return json.loads(config_map["SDK"].body)
-    except json.JSONDecodeError:
-        return {}
-
-
-
-def parse_first_message_signals(sdk_config): # type: ignore
-    """
-    Parses the trace, logs, and metrics signals configuration from the SDK config.
-    """
-
-    return {
-        "traceSignal": sdk_config.get("traceSignal", {}).get("enabled", False),
-        "metricsSignal": sdk_config.get("metricsSignal", {}).get("enabled", False),
-        "logsSignal": sdk_config.get("logsSignal", {}).get("enabled", False),
-    }