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

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

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

{odigos_opentelemetry_python-1.0.81 → odigos_opentelemetry_python-1.0.83}/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
@@ -247,27 +267,20 @@ def update_agent_config(conf: Config):
     if provider is None:
         return
 
-    # Update sampler configuration if sample_config is present
-    if hasattr(conf, 'sample_config') and conf.sample_config:
-        # Extract headSampling configuration from traces.headSampling
+    # Update sampler configuration if container_config is present
+    if hasattr(conf, 'container_config') and conf.container_config:
         head_sampling_config = None
-        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
+        if 'traces' in conf.container_config and 'headSampling' in conf.container_config['traces']:
+            head_sampling_config = conf.container_config['traces']['headSampling']
 
         # 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 +294,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.81 → odigos_opentelemetry_python-1.0.83}/initializer/odigos_sampler.py

@@ -6,7 +6,7 @@ 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.trace import Link, SpanKind, TraceState
+from opentelemetry.trace import Link, SpanKind, TraceState, get_current_span
 from opentelemetry.util.types import Attributes
 
 from initializer.schemas.sampling import (
@@ -30,6 +30,11 @@ class OdigosSampler(Sampler):
         self._lock = Lock()
         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
@@ -52,6 +57,17 @@ class OdigosSampler(Sampler):
     ) -> "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:
@@ -109,7 +125,7 @@ class OdigosSampler(Sampler):
                     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, trace_state=trace_state)
+                    return SamplingResult(self._not_sampled_decision(), trace_state=trace_state)
 
             # 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))
@@ -199,7 +215,6 @@ class OdigosSampler(Sampler):
 
     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(

{odigos_opentelemetry_python-1.0.81 → odigos_opentelemetry_python-1.0.83}/initializer/schemas/sampling.py

@@ -36,4 +36,5 @@ class NoisyOperation(TypedDict, total=False):
 
 class HeadSamplingConfig(TypedDict, total=False):
     dryRun: bool
+    spanMetricsMode: str
     noisyOperations: list[NoisyOperation]

odigos_opentelemetry_python-1.0.83/initializer/version.py

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

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

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

{odigos_opentelemetry_python-1.0.81 → odigos_opentelemetry_python-1.0.83}/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)
+    container_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.81 → odigos_opentelemetry_python-1.0.83}/opamp/http_client.py

@@ -23,7 +23,7 @@ from initializer.process_resource import PROCESS_VPID
 from google.protobuf.json_format import MessageToDict
 from google.protobuf.message import DecodeError
 
-from opamp.config import from_dict, Config
+from opamp.config import from_dict, Config, CodeAttributes
 
 # Setup the logger
 opamp_logger = logging.getLogger('odigos')
@@ -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
 
-                        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)
+                        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)
@@ -164,8 +183,7 @@ class OpAMPHTTPClient:
                             self.opamp_connection_event.error = False
                         return
 
-            except Exception as e:
-                # opamp_logger.error(f"Attempt {attempt}/{max_retries} failed. Error sending full state to OpAMP server: {e}")
+            except Exception:
                 pass
 
             if attempt < max_retries:
@@ -179,10 +197,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 +245,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 +257,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))
 
@@ -284,29 +303,34 @@ class OpAMPHTTPClient:
                 # If not JSON, just keep it as raw bytes
                 decoded_map[key] = body_bytes
 
-        inner = decoded_map.get("", None)
-        if inner is None:
-            config = Config() # Return default values for config
-        else:
-            config = from_dict(Config, inner)
+        config = Config()
 
         # Extract container_config if present
-        sample_config = decoded_map.get("container_config", None)
-        if sample_config is not None:
-            config.sample_config = sample_config
+        container_config = decoded_map.get("container_config", None)
+        if container_config is not None:
+            config.container_config = container_config
+
+            traces = container_config.get('traces', {})
+
+            span_metrics_mode = traces.get('headSampling', {}).get('spanMetricsMode')
+            if span_metrics_mode is not None:
+                config.span_metrics_mode = span_metrics_mode
+
+            code_attrs_raw = traces.get('codeAttributes')
+            if isinstance(code_attrs_raw, dict):
+                config.code_attributes = from_dict(CodeAttributes, code_attrs_raw)
 
         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)
@@ -441,27 +456,23 @@ class OpAMPHTTPClient:
 
     def _extract_sampler_config(self, remote_config):
         """Extract sampler config from remote config, same logic as update_agent_config"""
-        if not hasattr(remote_config, 'sample_config') or not remote_config.sample_config:
+        if not hasattr(remote_config, 'container_config') or not remote_config.container_config:
             return None
 
         # Extract headSampling configuration from traces.headSampling
-        if 'traces' not in remote_config.sample_config or 'headSampling' not in remote_config.sample_config['traces']:
+        if 'traces' not in remote_config.container_config or 'headSampling' not in remote_config.container_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.container_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.81 → odigos_opentelemetry_python-1.0.83}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "odigos-opentelemetry-python"
-version = "1.0.81"
+version = "1.0.83"
 description = "Odigos Initializer for Python OpenTelemetry Components"
 requires-python = ">=3.9"
 authors = [
@@ -145,6 +145,9 @@ extend-exclude = [
 # 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"

odigos_opentelemetry_python-1.0.81/initializer/version.py

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