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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odigos-opentelemetry-python
-Version: 1.0.80
+Version: 1.0.82
 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.82}/initializer/components.py

@@ -27,7 +27,6 @@ from opentelemetry.sdk.resources import OTELResourceDetector
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.trace import set_tracer_provider, get_tracer_provider
-from opentelemetry.sdk.trace.sampling import ParentBased
 
 
 # Move Odigos agent paths to the end of sys.path so the application's packages are
@@ -48,19 +47,19 @@ from opamp.config import Config
 from opamp import opamp_registry
 from .distro import instrumentation_registry
 
-
 from opamp.http_client import OpAMPHTTPClient, MockOpAMPClient
+from opamp.utils import parse_first_message_signals
 
 MINIMUM_PYTHON_SUPPORTED_VERSION = (3, 9)
 
 _odigos_sampler = None
 
 
-def initialize_components(trace_exporters = False, span_processor = None):
+def initialize_components(trace_exporters=False, span_processor=None):
     # Ensure each child process after fork gets a fresh OpAMP client
     # and correct process.* resource attributes.
     os.register_at_fork(
-    after_in_child=_after_in_child,
+        after_in_child=_after_in_child,
     )  # pylint: disable=protected-access
 
     handle_instrumenation_of_sub_processes()
@@ -69,24 +68,29 @@ def initialize_components(trace_exporters = False, span_processor = None):
     client = None
 
     try:
-
         client = start_opamp_client(opamp_connection_event)
 
         ## In case of error, e.g during the first connection to the OpAMP server,
         # we will use the default value which is enable traces only.
         if opamp_connection_event.error:
+            container_config = None
             supported_signals = {"traceSignal": True}
-            initial_sampler_config = None  # No config available due to connection error
+            initial_sampler_config = None
+            initial_remote_config = None
         else:
-            supported_signals = client.signals
+            container_config = client.container_config
+            supported_signals = parse_first_message_signals(container_config)
 
-            # Get initial sampler config directly from client (only when connection is successful)
+            # Get initial configs directly from client (only when connection is successful)
             try:
                 initial_sampler_config = client.get_initial_sampler_config()
             except AttributeError:
-                # Fallback to None to avoid errors
                 initial_sampler_config = None
 
+            try:
+                initial_remote_config = client.get_initial_remote_config()
+            except AttributeError:
+                initial_remote_config = None
 
         handle_django_instrumentation()
 
@@ -96,15 +100,20 @@ def initialize_components(trace_exporters = False, span_processor = None):
         }
 
         base_resource = (
-            OdigosProcessResourceDetector(client.pid).detect()
-            .merge(OTELResourceDetector().detect())
-            .merge(Resource.create(auto_resource))
+            OdigosProcessResourceDetector(client.pid).detect().merge(OTELResourceDetector().detect()).merge(Resource.create(auto_resource))
         )
 
         # Wrap in proxy so child processes can refresh automatically
         resource = ProxyResource(base_resource, OdigosProcessResourceDetector)
 
-        odigos_sampler = initialize_traces_if_enabled(trace_exporters, resource, span_processor, supported_signals, initial_sampler_config)
+        odigos_sampler = initialize_traces_if_enabled(
+            trace_exporters,
+            resource,
+            span_processor,
+            supported_signals,
+            initial_sampler_config,
+            initial_remote_config,
+        )
         if odigos_sampler is not None:
             client.sampler = odigos_sampler
 
@@ -119,16 +128,22 @@ def initialize_components(trace_exporters = False, span_processor = None):
         # Make sure the distro modules are reloaded even if an exception is raised.
         reload_distro_modules()
 
-def initialize_traces_if_enabled(trace_exporters, resource, span_processor = None, signals = None, initial_sampler_config = None):
+
+def initialize_traces_if_enabled(
+    trace_exporters,
+    resource,
+    span_processor=None,
+    signals=None,
+    initial_sampler_config=None,
+    initial_remote_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)
         if initial_sampler_config is not None:
@@ -136,7 +151,7 @@ def initialize_traces_if_enabled(trace_exporters, resource, span_processor = Non
 
         # Exporting using exporters
         if trace_exporters:
-            provider = TracerProvider(resource=resource, sampler=sampler)
+            provider = TracerProvider(resource=resource, sampler=odigos_sampler)
             id_generator_name = sdk_config._get_id_generator()
             id_generator = sdk_config._import_id_generator(id_generator_name)
             provider.id_generator = id_generator
@@ -147,21 +162,26 @@ def initialize_traces_if_enabled(trace_exporters, resource, span_processor = Non
 
             for _, exporter_class in exporters.items():
                 exporter_args = {}
-                provider.add_span_processor(
-                    BatchSpanProcessor(exporter_class(**exporter_args))
-                )
+                provider.add_span_processor(BatchSpanProcessor(exporter_class(**exporter_args)))
 
         # Exporting using EBPF
         else:
-            provider = TracerProvider(resource=resource, sampler=sampler)
+            provider = TracerProvider(resource=resource, sampler=odigos_sampler)
             set_tracer_provider(provider)
             if span_processor is not None:
                 provider.add_span_processor(span_processor)
 
+            # Bootstrap processor config from the first OpAMP message.
+            # The update_conf_cb fires before the TracerProvider exists,
+            # so the processor misses the initial config; apply it now.
+            if initial_remote_config is not None and span_processor is not None and hasattr(span_processor, 'update_config'):
+                span_processor.update_config(initial_remote_config)
+
         return odigos_sampler
 
     return None
 
+
 def initialize_metrics_if_enabled(resource, signals):
     # Currently we're not exporting metrics using the OTEL exporter.
     metrics_enabled = False
@@ -198,7 +218,6 @@ def start_opamp_client(event):
 
     python_version_supported = is_supported_python_version()
 
-
     client.start(python_version_supported)
 
     # Wait for the opamp first message to be received
@@ -230,6 +249,7 @@ def start_opamp_client(event):
 
     return client
 
+
 def update_agent_config(conf: Config):
     """
     The function `update_agent_config` checks for a tracer provider and updates its configuration using
@@ -254,20 +274,14 @@ 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']
 
-        if head_sampling_config and (
-            head_sampling_config.get('noisyOperations') is not None
-        ):
-            valid_config = head_sampling_config
-        else:
-            valid_config = None
-
         # Apply config to sampler - sampler will always exist when this callback is called
         # because update_agent_config is only called from OpAMP worker thread after sampler creation
         from opamp import opamp_registry
+
         client = opamp_registry.get_client()
 
         if client and hasattr(client, 'sampler') and client.sampler:
-            client.sampler.update_config(valid_config)
+            client.sampler.update_config(head_sampling_config)
         else:
             # This should not happen in normal operation
             pass
@@ -281,19 +295,17 @@ def update_agent_config(conf: Config):
     # If you attached only one BatchSpanProcessor, _active_span_processor
     # *is* that object.  If you attached several, it is a MultiSpanProcessor
     # that wraps them in ._span_processors.
-    processors = (
-        active_proc._span_processors
-        if hasattr(active_proc, "_span_processors")
-        else [active_proc]
-    )
+    processors = active_proc._span_processors if hasattr(active_proc, "_span_processors") else [active_proc]
 
     for proc in processors:
         if hasattr(proc, "update_config"):
             proc.update_config(conf)
 
+
 def is_supported_python_version():
     return sys.version_info >= MINIMUM_PYTHON_SUPPORTED_VERSION
 
+
 def handle_instrumenation_of_sub_processes():
     # Resolves a path management issue introduced by OpenTelemetry's sitecustomize implementation.
     # OpenTelemetry removed auto_instrumentation from the path to address a specific bug

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

@@ -1,85 +1,137 @@
+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, get_current_span
+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 _not_sampled_decision(self) -> Decision:
+        if self._config and self._config.get('spanMetricsMode') == "all-spans":
+            return Decision.RECORD_ONLY
+        return Decision.DROP
 
     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:
+            parent_span_context = get_current_span(parent_context).get_span_context()
+
+            # Parent-based logic taken from upstream ParentBased sampler so we can
+            # decide to DROP or RECORD_ONLY based on the recordMode configuration.
+            # Remote/local parent distinction is removed because both paths used the
+            # same not-sampled decision.
+            if parent_span_context is not None and parent_span_context.is_valid:
+                if parent_span_context.trace_flags.sampled:
+                    return SamplingResult(Decision.RECORD_AND_SAMPLE, attributes=attributes, trace_state=_get_parent_trace_state(parent_context))
+                else:
+                    return SamplingResult(self._not_sampled_decision(), trace_state=_get_parent_trace_state(parent_context))
             # 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
+            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(self._not_sampled_decision(), 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 +139,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 +158,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 +166,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,11 +210,30 @@ class OdigosSampler(Sampler):
 
         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
+
+    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.82/initializer/schemas/sampling.py

@@ -0,0 +1,40 @@
+"""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
+    spanMetricsMode: str
+    noisyOperations: list[NoisyOperation]

odigos_opentelemetry_python-1.0.82/initializer/version.py

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

{odigos_opentelemetry_python-1.0.80 → odigos_opentelemetry_python-1.0.82}/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.82
 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.82}/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.82}/opamp/config.py

@@ -1,38 +1,45 @@
 import re
 from dataclasses import dataclass, fields, field
-from typing import Any, Dict, Type, TypeVar, get_type_hints
+from typing import Any, Dict, Optional, Type, TypeVar, get_type_hints
 
 T = TypeVar("T")
 
+
 ###             Configuration structs           ###
 class DefaultNoneMixin:
-    #__getattr__ is only invoked when the normal attribute lookup (__dict__, class attributes, etc.) fails.
+    # __getattr__ is only invoked when the normal attribute lookup (__dict__, class attributes, etc.) fails.
     # Prevent raising a ValueError when accessing a non existing key
     # It'll save us multiple try catch blocks in the future
     def __getattr__(self, name: str):
         return None
 
+
 @dataclass
 class CodeAttributes(DefaultNoneMixin):
-    column:      bool = False
-    file_path:   bool = False
-    function:    bool = False
+    column: bool = False
+    file_path: bool = False
+    function: bool = False
     line_number: bool = False
-    namespace:   bool = False
+    namespace: bool = False
     stack_trace: bool = False
 
+
 @dataclass
 class Config(DefaultNoneMixin):
     code_attributes: CodeAttributes = field(default_factory=CodeAttributes)
     sample_config: Dict[str, Any] = field(default_factory=dict)
+    span_metrics_mode: Optional[str] = None
+
 
 ###             Helpers             ###
 
+
 def camel_to_snake(name: str) -> str:
     """Convert camelCase or PascalCase to snake_case."""
     s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
     return s1.lower()
 
+
 def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
     """
     Instantiate the dataclass `cls` from `data`:

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

@@ -33,31 +33,32 @@ _debugger_instance = None
 env_var_mappings = {
     "ODIGOS_WORKLOAD_NAMESPACE": ResourceAttributes.K8S_NAMESPACE_NAME,
     "ODIGOS_CONTAINER_NAME": ResourceAttributes.K8S_CONTAINER_NAME,
-    "ODIGOS_POD_NAME": ResourceAttributes.K8S_POD_NAME
+    "ODIGOS_POD_NAME": ResourceAttributes.K8S_POD_NAME,
 }
 
+
 class OpAMPHTTPClient:
     def __init__(self, opamp_connection_event, condition: threading.Condition):
         self.server_host = os.getenv('ODIGOS_OPAMP_SERVER_HOST')
         self.server_url = f"http://{self.server_host}/v1/opamp"
-        self.signals = {}
+        self.container_config = {}
         self.running = True
         self.condition = condition
         self.opamp_connection_event = opamp_connection_event
         self.next_sequence_num = 0
         self.instance_uid = uuid7().__str__()
         self.remote_config_status = None
-        self.sampler = None # OdigosSampler instance
+        self.sampler = None  # OdigosSampler instance
         self.pid = os.getpid()
-        self.update_conf_cb = None # Callback for configuration updates in the processor
-        self._initial_sampler_config = None # Store initial sampler config for direct access
+        self.update_conf_cb = None  # Callback for configuration updates in the processor
+        self._initial_sampler_config = None  # Store initial sampler config for direct access
+        self._initial_remote_config = None  # Store initial full Config for processor bootstrap
 
     def __repr__(self):
         return f"<OpAMPHTTPClient instance_uid={self.instance_uid} pid={self.pid}>"
 
     def start(self, python_version_supported: bool = None):
         if not python_version_supported:
-
             python_version = f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}'
             error_message = f"Opentelemetry SDK require Python in version 3.8 or higher [{python_version} is not supported]"
 
@@ -101,7 +102,11 @@ class OpAMPHTTPClient:
         agent_disconnect = self.get_agent_disconnect()
         agent_failure_message.agent_disconnect.CopyFrom(agent_disconnect)
 
-        agent_health = self.get_agent_health(component_health=component_health, last_error=error_message, status=AgentHealthStatus.AGENT_FAILURE.value)
+        agent_health = self.get_agent_health(
+            component_health=component_health,
+            last_error=error_message,
+            status=AgentHealthStatus.AGENT_FAILURE.value,
+        )
         agent_failure_message.health.CopyFrom(agent_health)
 
         return agent_failure_message
@@ -116,7 +121,11 @@ class OpAMPHTTPClient:
         agent_disconnect = self.get_agent_disconnect()
         first_disconnect_message.agent_disconnect.CopyFrom(agent_disconnect)
 
-        agent_health = self.get_agent_health(component_health=False, last_error=error_message, status=AgentHealthStatus.UNSUPPORTED_RUNTIME_VERSION.value)
+        agent_health = self.get_agent_health(
+            component_health=False,
+            last_error=error_message,
+            status=AgentHealthStatus.UNSUPPORTED_RUNTIME_VERSION.value,
+        )
         first_disconnect_message.health.CopyFrom(agent_health)
 
         self.send_agent_to_server_message(first_disconnect_message)
@@ -127,9 +136,19 @@ class OpAMPHTTPClient:
         for attempt in range(1, max_retries + 1):
             try:
                 # Send first message to OpAMP server, Health is false as the component is not initialized
-                agent_health = self.get_agent_health(component_health=False, last_error="Connecting to Odigos configuration server", status=AgentHealthStatus.STARTING.value)
+                agent_health = self.get_agent_health(
+                    component_health=False,
+                    last_error="Connecting to Odigos configuration server",
+                    status=AgentHealthStatus.STARTING.value,
+                )
                 agent_description = self.get_agent_description()
-                first_message_server_to_agent = self.send_agent_to_server_message(opamp_pb2.AgentToServer(agent_description=agent_description, health=agent_health, remote_config_status=opamp_pb2.RemoteConfigStatus()))
+                first_message_server_to_agent = self.send_agent_to_server_message(
+                    opamp_pb2.AgentToServer(
+                        agent_description=agent_description,
+                        health=agent_health,
+                        remote_config_status=opamp_pb2.RemoteConfigStatus(),
+                    )
+                )
 
                 # Check if the response of the first message is empty
                 # It may happen if OpAMPServer is not available
@@ -147,12 +166,12 @@ 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)
+                        self.container_config = utils.get_container_config(first_message_server_to_agent.remote_config.config.config_map)
 
-                        # Store initial sampler config for direct access
+                        # Store initial configs for direct access (TracerProvider doesn't exist yet)
                         remote_config = self.get_remote_config(first_message_server_to_agent)
                         self._initial_sampler_config = self._extract_sampler_config(remote_config)
+                        self._initial_remote_config = remote_config
 
                         # Send healthy message to OpAMP server
                         agent_health = self.get_agent_health(component_health=True, status=AgentHealthStatus.HEALTHY.value)
@@ -165,7 +184,7 @@ class OpAMPHTTPClient:
                         return
 
             except Exception as e:
-                # opamp_logger.error(f"Attempt {attempt}/{max_retries} failed. Error sending full state to OpAMP server: {e}")
+                print(f"[send_first_message_with_retry] Error: {e}", flush=True)
                 pass
 
             if attempt < max_retries:
@@ -179,10 +198,19 @@ class OpAMPHTTPClient:
 
         # If OpAMP server is throttling, it might not respond in the OpAMP client timeout period (5s).
         # In this case, we're trying to send a message to the OpAMP server to indicate that OpAMP is not available.
-        agent_health = self.get_agent_health(component_health=False, last_error="Failed to connect to Odigos configuration server - dynamic configuration unavailable",
-                                             status=AgentHealthStatus.NO_CONNECTION_TO_OPAMP_SERVER.value)
+        agent_health = self.get_agent_health(
+            component_health=False,
+            last_error="Failed to connect to Odigos configuration server - dynamic configuration unavailable",
+            status=AgentHealthStatus.NO_CONNECTION_TO_OPAMP_SERVER.value,
+        )
         agent_description = self.get_agent_description()
-        self.send_agent_to_server_message(opamp_pb2.AgentToServer(agent_description=agent_description, health=agent_health, remote_config_status=opamp_pb2.RemoteConfigStatus()))
+        self.send_agent_to_server_message(
+            opamp_pb2.AgentToServer(
+                agent_description=agent_description,
+                health=agent_health,
+                remote_config_status=opamp_pb2.RemoteConfigStatus(),
+            )
+        )
 
     def worker(self):
         while self.running:
@@ -218,8 +246,7 @@ class OpAMPHTTPClient:
                                     # The default config is preloaded when the EBPFSpanProcessor is initialized
                                     pass
 
-                except requests_odigos.RequestException as e:
-                    # opamp_logger.error(f"Error fetching data: {e}")
+                except requests_odigos.RequestException:
                     pass
                 self.condition.wait(30)
 
@@ -231,16 +258,9 @@ class OpAMPHTTPClient:
         component_health_map = {}
 
         for lib_name, lib_details in instrumented_libraries.items():
-            component_health_map[lib_name] = opamp_pb2.ComponentHealth(
-                healthy=True,
-                status=json.dumps(lib_details)
-            )
+            component_health_map[lib_name] = opamp_pb2.ComponentHealth(healthy=True, status=json.dumps(lib_details))
 
-        health_msg = opamp_pb2.ComponentHealth(
-            healthy=True,
-            status="instrumentation libraries report",
-            component_health_map=component_health_map
-        )
+        health_msg = opamp_pb2.ComponentHealth(healthy=True, status="instrumentation libraries report", component_health_map=component_health_map)
 
         self.send_agent_to_server_message(opamp_pb2.AgentToServer(health=health_msg))
 
@@ -286,7 +306,7 @@ class OpAMPHTTPClient:
 
         inner = decoded_map.get("", None)
         if inner is None:
-            config = Config() # Return default values for config
+            config = Config()  # Return default values for config
         else:
             config = from_dict(Config, inner)
 
@@ -295,18 +315,22 @@ class OpAMPHTTPClient:
         if sample_config is not None:
             config.sample_config = sample_config
 
+            try:
+                config.span_metrics_mode = sample_config['traces']['headSampling']['spanMetricsMode']
+            except (KeyError, TypeError):
+                pass
+
         return config
 
-    def send_heartbeat(self) -> opamp_pb2.ServerToAgent: # type: ignore
+    def send_heartbeat(self) -> opamp_pb2.ServerToAgent:  # type: ignore
         # opamp_logger.debug("Sending heartbeat to OpAMP server...")
         try:
             agent_to_server = opamp_pb2.AgentToServer(remote_config_status=self.remote_config_status)
             return self.send_agent_to_server_message(agent_to_server)
-        except requests_odigos.RequestException as e:
-            # opamp_logger.error(f"Error sending heartbeat to OpAMP server: {e}")
+        except requests_odigos.RequestException:
             pass
 
-    def get_agent_description(self) -> opamp_pb2.AgentDescription: # type: ignore
+    def get_agent_description(self) -> opamp_pb2.AgentDescription:  # type: ignore
         # The "DISABLE_OPAMP_CLIENT" environment variable is defined only in our VMs environments.
         # Here we use it exclusively to distinguish between virtual machine and Kubernetes environments.
         #
@@ -325,42 +349,24 @@ class OpAMPHTTPClient:
             process_id_key = PROCESS_VPID
 
         identifying_attributes = [
-            anyvalue_pb2.KeyValue(
-                key=ResourceAttributes.SERVICE_INSTANCE_ID,
-                value=anyvalue_pb2.AnyValue(string_value=self.instance_uid)
-            ),
-            anyvalue_pb2.KeyValue(
-                key=process_id_key,
-                value=anyvalue_pb2.AnyValue(int_value=self.pid)
-            ),
-            anyvalue_pb2.KeyValue(
-                key=ResourceAttributes.TELEMETRY_SDK_LANGUAGE,
-                value=anyvalue_pb2.AnyValue(string_value="python")
-            )
+            anyvalue_pb2.KeyValue(key=ResourceAttributes.SERVICE_INSTANCE_ID, value=anyvalue_pb2.AnyValue(string_value=self.instance_uid)),
+            anyvalue_pb2.KeyValue(key=process_id_key, value=anyvalue_pb2.AnyValue(int_value=self.pid)),
+            anyvalue_pb2.KeyValue(key=ResourceAttributes.TELEMETRY_SDK_LANGUAGE, value=anyvalue_pb2.AnyValue(string_value="python")),
         ]
 
         # Add additional attributes from environment variables
         for env_var, attribute_key in env_var_mappings.items():
             value = os.environ.get(env_var)
             if value:
-                identifying_attributes.append(
-                    anyvalue_pb2.KeyValue(
-                        key=attribute_key,
-                        value=anyvalue_pb2.AnyValue(string_value=value)
-                    )
-                )
+                identifying_attributes.append(anyvalue_pb2.KeyValue(key=attribute_key, value=anyvalue_pb2.AnyValue(string_value=value)))
 
-        return opamp_pb2.AgentDescription(
-            identifying_attributes=identifying_attributes,
-            non_identifying_attributes=[]
-        )
+        return opamp_pb2.AgentDescription(identifying_attributes=identifying_attributes, non_identifying_attributes=[])
 
-    def get_agent_disconnect(self) -> opamp_pb2.AgentDisconnect: # type: ignore
+    def get_agent_disconnect(self) -> opamp_pb2.AgentDisconnect:  # type: ignore
         return opamp_pb2.AgentDisconnect()
 
-    def get_agent_health(self, component_health: bool = None, last_error : str = None, status: str = None) -> opamp_pb2.ComponentHealth: # type: ignore
-        health = opamp_pb2.ComponentHealth(
-        )
+    def get_agent_health(self, component_health: bool = None, last_error: str = None, status: str = None) -> opamp_pb2.ComponentHealth:  # type: ignore
+        health = opamp_pb2.ComponentHealth()
         if component_health is not None:
             health.healthy = component_health
         if last_error is not None:
@@ -370,8 +376,7 @@ class OpAMPHTTPClient:
 
         return health
 
-
-    def send_agent_to_server_message(self, message: opamp_pb2.AgentToServer) -> opamp_pb2.ServerToAgent: # type: ignore
+    def send_agent_to_server_message(self, message: opamp_pb2.AgentToServer) -> opamp_pb2.ServerToAgent:  # type: ignore
 
         message.instance_uid = self.instance_uid.encode('utf-8')
         message.sequence_num = self.next_sequence_num
@@ -417,10 +422,20 @@ class OpAMPHTTPClient:
         self.running = False
         # opamp_logger.info("Sending agent disconnect message to OpAMP server...")
         if custom_failure_message:
-            disconnect_message = self.get_agent_failure_disconnect_message(error_message=custom_failure_message, component_health=component_health)
+            disconnect_message = self.get_agent_failure_disconnect_message(
+                error_message=custom_failure_message,
+                component_health=component_health,
+            )
         else:
-            agent_health = self.get_agent_health(component_health=component_health, last_error="Python runtime is exiting", status=AgentHealthStatus.TERMINATED.value)
-            disconnect_message = opamp_pb2.AgentToServer(agent_disconnect=opamp_pb2.AgentDisconnect(), health=agent_health)
+            agent_health = self.get_agent_health(
+                component_health=component_health,
+                last_error="Python runtime is exiting",
+                status=AgentHealthStatus.TERMINATED.value,
+            )
+            disconnect_message = opamp_pb2.AgentToServer(
+                agent_disconnect=opamp_pb2.AgentDisconnect(),
+                health=agent_health,
+            )
 
         with self.condition:
             self.condition.notify_all()
@@ -428,7 +443,7 @@ class OpAMPHTTPClient:
 
         self.send_agent_to_server_message(disconnect_message)
 
-    def update_remote_config_status(self, server_to_agent: opamp_pb2.ServerToAgent) -> bool: # type: ignore
+    def update_remote_config_status(self, server_to_agent: opamp_pb2.ServerToAgent) -> bool:  # type: ignore
         if server_to_agent.HasField("remote_config"):
             remote_config_hash = server_to_agent.remote_config.config_hash
             remote_config_status = opamp_pb2.RemoteConfigStatus(last_remote_config_hash=remote_config_hash)
@@ -448,20 +463,16 @@ class OpAMPHTTPClient:
         if 'traces' not in remote_config.sample_config or 'headSampling' not in remote_config.sample_config['traces']:
             return None
 
-        head_sampling_config = remote_config.sample_config['traces']['headSampling']
-
-        # Check if we have valid sampling config (same validation as update_agent_config)
-        if head_sampling_config and (
-            head_sampling_config.get('noisyOperations') is not None
-        ):
-            return head_sampling_config
-        else:
-            return None
+        return remote_config.sample_config['traces']['headSampling'] or None
 
     def get_initial_sampler_config(self):
         """Get the sampler config from the initial OpAMP message"""
         return self._initial_sampler_config
 
+    def get_initial_remote_config(self):
+        """Get the full Config from the initial OpAMP message"""
+        return self._initial_remote_config
+
 
 # Mock client class for non-OpAMP installations
 # This class simulates the OpAMP client when the OpAMP server is not available.
@@ -469,7 +480,7 @@ class OpAMPHTTPClient:
 class MockOpAMPClient:
     def __init__(self, opamp_connection_event, *args, **kwargs):
         self.pid = os.getpid()
-        self.signals = {'traceSignal': True}
+        self.container_config = {"traces": {}}
         self.sampler = None  # For compatibility
         opamp_connection_event.event.set()
 
@@ -477,5 +488,9 @@ class MockOpAMPClient:
         """Mock client has no sampler config"""
         return None
 
+    def get_initial_remote_config(self):
+        """Mock client has no remote config"""
+        return None
+
     def shutdown(self, custom_failure_message=None):
         pass

odigos_opentelemetry_python-1.0.82/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.82}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "odigos-opentelemetry-python"
-version = "1.0.80"
+version = "1.0.82"
 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,36 @@ 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.lint.per-file-ignores]
+"initializer/components.py" = ["E402"]
+
+[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),
-    }