odigos-opentelemetry-python 1.0.78__tar.gz → 1.0.79__tar.gz

{odigos_opentelemetry_python-1.0.78 → odigos_opentelemetry_python-1.0.79}/PKG-INFO

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

{odigos_opentelemetry_python-1.0.78 → odigos_opentelemetry_python-1.0.79}/initializer/components.py

@@ -53,6 +53,8 @@ from opamp.http_client import OpAMPHTTPClient, MockOpAMPClient
 
 MINIMUM_PYTHON_SUPPORTED_VERSION = (3, 9)
 
+_odigos_sampler = None
+
 
 def initialize_components(trace_exporters = False, span_processor = None):
     # Ensure each child process after fork gets a fresh OpAMP client
@@ -118,12 +120,14 @@ def initialize_components(trace_exporters = False, span_processor = None):
         reload_distro_modules()
 
 def initialize_traces_if_enabled(trace_exporters, resource, span_processor = None, signals = None, initial_sampler_config = None):
+    global _odigos_sampler
     # In case collectors signals support receiving traces, initialize the tracer provider with the exporters
     traces_enabled = signals.get("traceSignal", False)
 
     if traces_enabled:
 
         odigos_sampler = OdigosSampler()
+        _odigos_sampler = odigos_sampler
         sampler = ParentBased(odigos_sampler)
 
         # Apply initial sampler config if provided (from OpAMP first message)
@@ -250,10 +254,8 @@ def update_agent_config(conf: Config):
         if 'traces' in conf.sample_config and 'headSampling' in conf.sample_config['traces']:
             head_sampling_config = conf.sample_config['traces']['headSampling']
 
-        # Determine if we have valid sampling config (rules or fallback fraction)
         if head_sampling_config and (
-            head_sampling_config.get('attributesAndSamplerRules') or
-            head_sampling_config.get('fallbackFraction') is not None
+            head_sampling_config.get('noisyOperations') is not None
         ):
             valid_config = head_sampling_config
         else:
@@ -370,11 +372,19 @@ class ProxyResource(Resource):
 
 def _after_in_child():
     # This hook runs in every child process after fork().
-    # It does two things:
-    # 1. Marks ProxyResource as "dirty", so the next time spans are created,
-    #    the process.* attributes are recomputed with the child’s PID.
+    # It does three things:
+    # 1. Marks ProxyResource as "dirty" so process.* attributes are recomputed.
     # 2. Restarts the OpAMP client (threads/sockets do not survive fork).
+    # 3. Propagates the sampler to the new client so config updates reach it.
+    #    Without this, the forked client's sampler is None and config updates
+    #    from OpAMP heartbeats are silently dropped.
     provider = get_tracer_provider()
     if isinstance(getattr(provider, "resource", None), ProxyResource):
         provider.resource._child_refreshed = False
-    start_opamp_client(OpampConnectionEvent())
+    client = start_opamp_client(OpampConnectionEvent())
+
+    if _odigos_sampler is not None:
+        client.sampler = _odigos_sampler
+        initial_config = client.get_initial_sampler_config()
+        if initial_config is not None:
+            _odigos_sampler.update_config(initial_config)

odigos_opentelemetry_python-1.0.79/initializer/odigos_sampler.py

@@ -0,0 +1,168 @@
+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
+
+
+# Setup the Sampler logger
+sampler_logger = logging.getLogger('odigos')
+
+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
+
+    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):
+        attributes = attributes or {}
+        with self._lock:
+            # sampler_logger.debug(f'Running Should_sample a span with the following attributes: {attributes}')
+
+            if self._config is None:
+                # 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
+
+            for noisy_operation in noisy_operations:
+                if noisy_operation.get("disabled"):
+                    continue
+
+                percentage_to_sample = noisy_operation.get("percentageAtMost", 0.0)
+
+                http_operation_sample = noisy_operation.get("operation")
+                if not http_operation_sample:
+                    continue
+
+                # 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
+
+                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):
+                    # 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))
+                else:
+                    # sampler_logger.debug(f'Trace [{trace_id}] is dropped with lowest percentage {lowest_percentage}')
+                    return SamplingResult(Decision.DROP)
+
+            # sampler_logger.debug(f'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):
+        """Return the first non-None value found for the given attribute keys."""
+        for key in keys:
+            value = span_attributes.get(key)
+            if value is not None:
+                return value
+        return None
+
+    def _match_http_server_sample_rule(self, http_server_rule: dict[str, str], span_attributes: dict[str, str]) -> bool:
+        """
+        Try to match all the http server's attributes to the definitions of the noisy action
+        """
+        span_route = span_attributes.get(http_attributes_semconv.HTTP_ROUTE)
+        # Old semconv: "http.method" → new semconv: "http.request.method"
+        span_method = self._get_attribute(span_attributes, http_attributes_semconv.HTTP_REQUEST_METHOD, "http.method")
+
+        # Some instrumentations send target instead of route
+        target = self._get_attribute(span_attributes, "http.target", "url.path")
+
+        if http_server_rule.get("route") and http_server_rule["route"] != span_route:
+            # If we have route in the span attributes, evaluate it first (use template matching
+            # since param names may differ, e.g. /grml/{grml_id} vs /grml/{path_param})
+            if span_route:
+                return self._match_rule_route_to_span(http_server_rule["route"], span_route)
+            # 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:
+            return False
+
+        return True
+
+    def _match_http_client_sample_rule(self, http_client_rule: dict[str, str], span_attributes: dict[str, str]) -> bool:
+        """
+        Try to match all the http client's attributes to the definitions of the noisy action
+        """
+        # Old semconv: "net.peer.name" / "http.host" → new semconv: "server.address"
+        server_address = self._get_attribute(span_attributes, server_attributes_semconv.SERVER_ADDRESS, "net.peer.name", "http.host")
+        url_template = span_attributes.get("url.template")
+        # Old semconv: "http.method" → new semconv: "http.request.method"
+        method = self._get_attribute(span_attributes, http_attributes_semconv.HTTP_REQUEST_METHOD, "http.method")
+
+        if http_client_rule.get("serverAddress") and http_client_rule["serverAddress"] != server_address:
+            return False
+        if http_client_rule.get("templatedPath") and http_client_rule["templatedPath"] != url_template:
+            return False
+        if http_client_rule.get("templatedPathPrefix") and not (url_template or "").startswith(http_client_rule["templatedPathPrefix"]):
+            return False
+        if http_client_rule.get("method") and http_client_rule["method"] != method:
+            return False
+
+        return True
+
+    def _match_rule_route_to_span(self, rule_route: str, span_value: str) -> bool:
+        """
+        Match a sampling rule route (e.g. /item/{id}) against a span value, which can be either
+        a templated route (e.g. /item/{item_id}) or a full URL target (e.g. /item/123?param=hello).
+        Path param segments ({...}) in the rule are treated as wildcards.
+        """
+        span_value = span_value.split('?')[0]
+        rule_parts = [part for part in rule_route.split('/') if part]
+        span_parts = [part for part in span_value.split('/') if part]
+
+        if len(rule_parts) != len(span_parts):
+            return False
+
+        # Traverse both rule and span segments
+        for i in range(len(rule_parts)):
+            # If we hit a path param in the rule, it matches any span segment
+            if rule_parts[i].startswith('{'):
+                continue
+            if rule_parts[i] != span_parts[i]:
+                return False
+
+        return True
+
+
+    def get_description(self):
+        return "OdigosSampler"
+
+    def update_config(self, new_config):
+        with self._lock:
+            # sampler_logger.debug(f'Updating the configuration with the new configuration: {new_config}')
+            self._config = new_config

odigos_opentelemetry_python-1.0.79/initializer/version.py

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

{odigos_opentelemetry_python-1.0.78 → odigos_opentelemetry_python-1.0.79}/odigos_opentelemetry_python.egg-info/PKG-INFO

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

{odigos_opentelemetry_python-1.0.78 → odigos_opentelemetry_python-1.0.79}/odigos_opentelemetry_python.egg-info/SOURCES.txt

@@ -9,7 +9,6 @@ initializer/lib_handling.py
 initializer/odigos_sampler.py
 initializer/post_instrument.py
 initializer/process_resource.py
-initializer/sampling_operators.py
 initializer/version.py
 initializer/distro/__init__.py
 initializer/distro/distro.py

{odigos_opentelemetry_python-1.0.78 → odigos_opentelemetry_python-1.0.79}/opamp/http_client.py

@@ -452,8 +452,7 @@ class OpAMPHTTPClient:
 
         # Check if we have valid sampling config (same validation as update_agent_config)
         if head_sampling_config and (
-            head_sampling_config.get('attributesAndSamplerRules') or
-            head_sampling_config.get('fallbackFraction') is not None
+            head_sampling_config.get('noisyOperations') is not None
         ):
             return head_sampling_config
         else:

{odigos_opentelemetry_python-1.0.78 → odigos_opentelemetry_python-1.0.79}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "odigos-opentelemetry-python"
-version = "1.0.78"
+version = "1.0.79"
 description = "Odigos Initializer for Python OpenTelemetry Components"
 requires-python = ">=3.9"
 authors = [

odigos_opentelemetry_python-1.0.78/initializer/odigos_sampler.py

@@ -1,98 +0,0 @@
-from .sampling_operators import SamplingOperators
-from opentelemetry.sdk.trace.sampling import Sampler, Decision, SamplingResult, _get_parent_trace_state
-from threading import Lock
-import logging
-
-# Setup the Sampler logger
-sampler_logger = logging.getLogger('odigos')
-
-class OdigosSampler(Sampler):
-
-    # Define the sampling operator functions used in the configuration.
-    # These operations are specified in the Odigos InstrumentationConfig Kubernetes object.
-    _operations = {
-        SamplingOperators.EQUALS.value: lambda attr, value: attr == value,
-        SamplingOperators.NOT_EQUALS.value: lambda attr, value: attr != value,
-        SamplingOperators.END_WITH.value: lambda attr, value: attr.endswith(value),
-        SamplingOperators.START_WITH.value: lambda attr, value: attr.startswith(value)
-    }
-
-    # 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
-
-    def _trace_id_based_sampling(self, trace_id, fraction):
-        """Mimic OpenTelemetry's trace ID-based sampling logic with 64-bit range."""
-        # 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):
-        with self._lock:
-            # sampler_logger.debug(f'Running Should_sample a span with the following attributes: {attributes}')
-
-            if self._config is None:
-                # 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))
-
-            rules = self._config.get('attributesAndSamplerRules', [])
-            global_fraction = self._config.get('fallbackFraction', 1) # default to 1 if not set which means always sample
-
-            for rule in rules: # The first attribute rule that evaluates to true is used to determine the sampling decision based on its fraction.
-                and_attributes_sampler_rules = rule.get('attributeConditions', [])
-
-                # sampler_logger.debug(f'"AND" rule operands are: {and_attributes_sampler_rules}')
-
-                and_rule_fraction = rule.get('fraction', 1) # default to 1 if not set which means always sample
-                and_rule_met = True
-
-                for and_rule in and_attributes_sampler_rules:
-                    # If the "AND" rule is not met once, break the loop to avoid unnecessary checks
-                    if not and_rule_met:
-                        break
-
-                    key = and_rule.get('key')
-                    value = and_rule.get('val')
-                    operator = and_rule.get('operator') # equals / notEquals / endWith / startWith
-
-                    if key in attributes:
-                        attr_value = attributes[key]
-                        # Perform the corresponding operation
-                        if operator in self._operations and self._operations[operator](attr_value, value):
-                            pass  # Condition matched
-                        else:
-                            # sampler_logger.debug(f'Operator {operator} is false, setting the "AND" rule flag to false')
-                            and_rule_met = False
-                    else:
-                        # sampler_logger.debug(f'Attribute {key} is not present in the span attributes, setting the "AND" rule flag to false')
-                        and_rule_met = False
-
-                if and_rule_met:
-                    # Perform the sampling decision
-                    if self._trace_id_based_sampling(trace_id, and_rule_fraction):
-                        # sampler_logger.debug(f'Trace [{trace_id}] is sampled "And rules" are met with fraction {and_rule_fraction}')
-                        return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=_get_parent_trace_state(parent_context))
-                    else:
-                        # sampler_logger.debug(f'Trace [{trace_id}] is dropped "And rules" are met but fraction {and_rule_fraction} not met')
-                        return SamplingResult(Decision.DROP)
-
-            # Fallback to the global fraction if no rule matches
-            # sampler_logger.debug(f'No rule matched, falling back to the global fraction {global_fraction}')
-            if self._trace_id_based_sampling(trace_id, global_fraction):
-                return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=_get_parent_trace_state(parent_context))
-            else:
-                return SamplingResult(Decision.DROP)
-
-
-    def get_description(self):
-        return "OdigosSampler"
-
-    def update_config(self, new_config):
-        with self._lock:
-            # sampler_logger.debug(f'Updating the configuration with the new configuration: {new_config}')
-            self._config = new_config

odigos_opentelemetry_python-1.0.78/initializer/sampling_operators.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-class SamplingOperators(str, Enum):
-    EQUALS = "equals"
-    NOT_EQUALS = "notEquals"
-    END_WITH = "endWith"
-    START_WITH = "startWith"

odigos_opentelemetry_python-1.0.78/initializer/version.py

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