odigos-opentelemetry-python 1.0.45__tar.gz → 1.0.46__tar.gz

{odigos_opentelemetry_python-1.0.45/odigos_opentelemetry_python.egg-info → odigos_opentelemetry_python-1.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odigos-opentelemetry-python
-Version: 1.0.45
+Version: 1.0.46
 Summary: Odigos Initializer for Python OpenTelemetry Components
 Author: Tamir David
 Author-email: tamir@odigos.io

{odigos_opentelemetry_python-1.0.45 → odigos_opentelemetry_python-1.0.46}/initializer/components.py

@@ -6,13 +6,14 @@ import threading
 import atexit
 import sys
 import os
+
 import opentelemetry.sdk._configuration as sdk_config
 from .process_resource import OdigosProcessResourceDetector
 from opentelemetry.sdk.resources import Resource
 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
+from opentelemetry.trace import set_tracer_provider, get_tracer_provider
 
 from .version import VERSION
 from .exit_hook import ExitHooks
@@ -21,6 +22,8 @@ from .envs import set_static_otel_env
 from .odigos_sampler import OdigosSampler
 from opentelemetry.sdk.trace.sampling import ParentBased
 
+from opamp.config import Config
+
 # Reorder the python sys.path to ensure that the user application's dependencies take precedence over the agent's dependencies.
 # This is necessary because the user application's dependencies may be incompatible with those used by the agent.
 reorder_python_path()
@@ -29,35 +32,35 @@ from opamp.http_client import OpAMPHTTPClient, MockOpAMPClient
 
 MINIMUM_PYTHON_SUPPORTED_VERSION = (3, 8)
 
+
 def initialize_components(trace_exporters = False, span_processor = None):
     # In case of forking, the OpAMP client should be started in the child process.
     # e.g when using gunicorn/celery with multiple workers.
     os.register_at_fork(
     after_in_child=lambda: start_opamp_client(threading.Event()),
     )  # pylint: disable=protected-access
-    
+
     handle_instrumenation_of_sub_processes()
 
     resource_attributes_event = threading.Event()
     client = None
-    
+
     try:
-        
+
         client = start_opamp_client(resource_attributes_event)
         resource_attributes_event.wait(timeout=30)  # Wait for the resource attributes to be received for 30 seconds
 
         supported_signals = client.signals
         received_value = client.resource_attributes
-        
-        if received_value:    
-        
+
+        if received_value:
             handle_django_instrumentation()
-            
+
             auto_resource = {
                 "telemetry.distro.name": "odigos",
                 "telemetry.distro.version": VERSION,
             }
-                        
+
             auto_resource.update(received_value)
 
             resource = OdigosProcessResourceDetector(client.pid).detect() \
@@ -70,15 +73,15 @@ def initialize_components(trace_exporters = False, span_processor = None):
 
             initialize_metrics_if_enabled(resource, supported_signals)
             initialize_logging_if_enabled(resource, supported_signals)
-            
-        else:    
+
+        else:
             raise Exception("Did not receive resource attributes from the OpAMP server.")
-        
+
     except Exception as e:
         if client is not None:
             client.shutdown(custom_failure_message=str(e))
         raise
-    
+
     finally:
         # Make sure the distro modules are reloaded even if an exception is raised.
         reload_distro_modules()
@@ -86,21 +89,21 @@ def initialize_components(trace_exporters = False, span_processor = None):
 def initialize_traces_if_enabled(trace_exporters, resource, span_processor = None, signals = None):
     # 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()
         sampler = ParentBased(odigos_sampler)
-        
+
         # Exporting using exporters
         if trace_exporters:
             provider = TracerProvider(resource=resource, sampler=sampler)
             id_generator_name = sdk_config._get_id_generator()
-            id_generator = sdk_config._import_id_generator(id_generator_name)            
+            id_generator = sdk_config._import_id_generator(id_generator_name)
             provider.id_generator = id_generator
-            
+
             set_tracer_provider(provider)
-            
+
             exporters, _, _ = sdk_config._import_exporters(["otlp_proto_http"], [], [])
 
             for _, exporter_class in exporters.items():
@@ -108,14 +111,14 @@ def initialize_traces_if_enabled(trace_exporters, resource, span_processor = Non
                 provider.add_span_processor(
                     BatchSpanProcessor(exporter_class(**exporter_args))
                 )
-                
+
         # Exporting using EBPF
         else:
             provider = TracerProvider(resource=resource, sampler=sampler)
             set_tracer_provider(provider)
             if span_processor is not None:
                 provider.add_span_processor(span_processor)
-            
+
         return odigos_sampler
 
     return None
@@ -123,17 +126,17 @@ def initialize_traces_if_enabled(trace_exporters, resource, span_processor = Non
 def initialize_metrics_if_enabled(resource, signals):
     # Currently we're not exporting metrics using the OTEL exporter.
     metrics_enabled = False
-    
+
     if metrics_enabled:
         _, exporters, _ = sdk_config._import_exporters([], ["otlp_proto_http"], [])
-        
+
         sdk_config._init_metrics(exporters, resource)
 
 
 def initialize_logging_if_enabled(resource, signals):
     # Logs are collected using the filelog receiver; currently, there is no need to export them using the OTEL exporter.
     logging_enabled = False
-    
+
     if logging_enabled:
         _, _, exporters = sdk_config._import_exporters([], [], ["otlp_proto_http"])
         sdk_config._init_logging(exporters, resource)
@@ -142,20 +145,23 @@ def initialize_logging_if_enabled(resource, signals):
 def start_opamp_client(event):
     if os.getenv('DISABLE_OPAMP_CLIENT', 'false').strip().lower() == 'true':
         return MockOpAMPClient(event)
-        
+
     # Setting static otel envs such as log correlation and exporter protocols
     set_static_otel_env()
-    
+
     condition = threading.Condition(threading.Lock())
     client = OpAMPHTTPClient(event, condition)
-    
+
+    # Register the configuration update callback for the processor
+    client.register_config_update_cb(update_agent_config)
+
     python_version_supported = is_supported_python_version()
 
     client.start(python_version_supported)
-    
+
     hooks = ExitHooks()
     hooks.hook()
-    
+
     def shutdown():
         if hooks.exit_code is not None and hooks.exit_code != 0:
             client.shutdown("Program exit with code: " + str(hooks.exit_code))
@@ -169,31 +175,65 @@ 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
+    processors if available.
+    It searches specifically for the EBPFSpanProcessor processes (Looking for the update_config attribute).
+
+    :param conf: The `conf` parameter in the `update_agent_config` function is of type `Config`. It is
+    used to update the configuration settings of the agent
+    :type conf: Config
+    :return: If the `provider` is `None` or if `active_proc` is `None`, then the function will return
+    without performing any further actions.
+    """
+    provider = get_tracer_provider()
+    if provider is None:
+        return
+
+    # The provider’s public API does not expose processors directly,
+    # but the private _active_span_processor attribute always exists.
+    active_proc = getattr(provider, "_active_span_processor", None)
+    if active_proc is None:
+        return
+
+    # 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]
+    )
+
+    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 
+    # OpenTelemetry removed auto_instrumentation from the path to address a specific bug
     # (ref: https://github.com/open-telemetry/opentelemetry-python-contrib/issues/1050).
-    # This modification does not impact our use case, as we utilize auto_instrumentation as a package 
+    # This modification does not impact our use case, as we utilize auto_instrumentation as a package
     # and do not rely on opentelemetry-instrument for running instrumentations.
-    # 
+    #
     # We are reintroducing the path to enable parallel execution with other agent that inject themselves via sitecustomize.
-    # We've observed that agents attempt to import user-defined sitecustomize.py [OpenTelemetry one in this case] prior to their own execution 
+    # We've observed that agents attempt to import user-defined sitecustomize.py [OpenTelemetry one in this case] prior to their own execution
     # to prevent application logic disruption.
-    # 
+    #
     # Given OpenTelemetry's path removal during Distro creation, we must manually restore the path.
     # This addresses cases where applications using os.exec* are not properly instrumented.
-    # 
+    #
     # Note: This is a temporary solution and should be refactored when:
     # - The environment override writer is removed
     # - Webhook integration is implemented
     # - A custom distro creation mechanism is developed
     auto_instrumentation_path = "/var/odigos/python/opentelemetry/instrumentation/auto_instrumentation"
     python_path = os.getenv("PYTHONPATH", "")
-    
+
     if auto_instrumentation_path not in python_path:
         new_python_path = f"{python_path}:{auto_instrumentation_path}" if python_path else auto_instrumentation_path
-        os.environ["PYTHONPATH"] = new_python_path
+        os.environ["PYTHONPATH"] = new_python_path

{odigos_opentelemetry_python-1.0.45 → odigos_opentelemetry_python-1.0.46/odigos_opentelemetry_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odigos-opentelemetry-python
-Version: 1.0.45
+Version: 1.0.46
 Summary: Odigos Initializer for Python OpenTelemetry Components
 Author: Tamir David
 Author-email: tamir@odigos.io

{odigos_opentelemetry_python-1.0.45 → odigos_opentelemetry_python-1.0.46}/odigos_opentelemetry_python.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ odigos_opentelemetry_python.egg-info/requires.txt
 odigos_opentelemetry_python.egg-info/top_level.txt
 opamp/__init__.py
 opamp/anyvalue_pb2.py
+opamp/config.py
 opamp/health_status.py
 opamp/http_client.py
 opamp/opamp_pb2.py

odigos_opentelemetry_python-1.0.46/opamp/config.py

@@ -0,0 +1,58 @@
+import re
+from dataclasses import dataclass, fields, field
+from typing import Any, Dict, 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.
+    # 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
+    line_number: bool = False
+    namespace:   bool = False
+    stack_trace: bool = False
+
+@dataclass
+class Config(DefaultNoneMixin):
+    code_attributes: CodeAttributes = field(default_factory=CodeAttributes)
+
+###             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`:
+      - Converts JSON camelCase keys to snake_case field names
+      - Ignores unknown keys
+      - Uses defaults for any missing fields
+      - Recurses if a field’s type is itself a dataclass
+    """
+    hints = get_type_hints(cls)
+    field_names = {f.name for f in fields(cls)}
+    init_args: Dict[str, Any] = {}
+    for raw_key, raw_val in data.items():
+        key = camel_to_snake(raw_key)
+        if key not in field_names:
+            continue
+
+        field_type = hints.get(key)
+        # If the field type is another dataclass, recurse
+        if hasattr(field_type, "__dataclass_fields__") and isinstance(raw_val, dict):
+            init_args[key] = from_dict(field_type, raw_val)
+        else:
+            init_args[key] = raw_val
+
+    return cls(**init_args)

{odigos_opentelemetry_python-1.0.45 → odigos_opentelemetry_python-1.0.46}/opamp/http_client.py

@@ -1,6 +1,8 @@
 import os
 import sys
+import json
 import time
+import base64
 import threading
 import requests_odigos
 import logging
@@ -18,9 +20,14 @@ from opamp import opamp_pb2, anyvalue_pb2, utils
 from opamp.health_status import AgentHealthStatus
 from initializer.process_resource import PROCESS_VPID
 
+from google.protobuf.json_format import MessageToDict
+
+from opamp.config import from_dict, Config
+
 # Setup the logger
 opamp_logger = logging.getLogger('odigos')
 
+_debugger_instance = None
 
 env_var_mappings = {
     "ODIGOS_WORKLOAD_NAMESPACE": ResourceAttributes.K8S_NAMESPACE_NAME,
@@ -42,72 +49,72 @@ class OpAMPHTTPClient:
         self.remote_config_status = None
         self.sampler = None # OdigosSampler instance
         self.pid = os.getpid()
+        self.update_conf_cb = None # Callback for configuration updates in the processor
 
 
     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]"
-            
+
             # opamp_logger.warning(f"{error_message}, sending disconnect message to OpAMP server...")
             self.send_unsupported_version_disconnect_message(error_message=error_message)
             self.event.set()
             return
-        
+
         self.client_thread = threading.Thread(target=self.run, name="OpAMPClientThread", daemon=True)
         self.client_thread.start()
-        
+
     def run(self):
         try:
             if not self.mandatory_env_vars_set():
                 self.event.set()
                 return
-            
+
             self.send_first_message_with_retry()
             self.event.set()
-            
+
             self.worker()
-            
+
         except Exception as e:
             # opamp_logger.error(f"Error running OpAMP client: {e}")
-            failure_message = self.get_agent_failure_disconnect_message(error_message=str(e))            
+            failure_message = self.get_agent_failure_disconnect_message(error_message=str(e))
             self.send_agent_to_server_message(failure_message)
-            
+
             # Exiting the opamp thread and set the event to notify the main thread
             self.event.set()
             sys.exit()
 
     def get_agent_failure_disconnect_message(self, error_message: str, component_health: bool = False) -> None:
         agent_failure_message = opamp_pb2.AgentToServer()
-        
+
         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_failure_message.health.CopyFrom(agent_health)
-        
+
         return agent_failure_message
-    
+
     def send_unsupported_version_disconnect_message(self, error_message: str) -> None:
         first_disconnect_message = opamp_pb2.AgentToServer()
-        
+
         agent_description = self.get_agent_description()
-        
+
         first_disconnect_message.agent_description.CopyFrom(agent_description)
-        
+
         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)
         first_disconnect_message.health.CopyFrom(agent_health)
-        
+
         self.send_agent_to_server_message(first_disconnect_message)
-        
+
     def send_first_message_with_retry(self) -> None:
         max_retries = 5
         delay = 2
-        
         for attempt in range(1, max_retries + 1):
             try:
                 # Send first message to OpAMP server, Health is false as the component is not initialized
@@ -117,28 +124,36 @@ class OpAMPHTTPClient:
 
                 # Check if the response of the first message is empty
                 # It may happen if OpAMPServer is not available
-                if first_message_server_to_agent.ListFields(): 
-                    self.update_remote_config_status(first_message_server_to_agent)
-                    
+                if first_message_server_to_agent.ListFields():
+                    if self.update_remote_config_status(server_to_agent):
+                        if server_to_agent.HasField("remote_config") and self.update_conf_cb:
+                            try:
+                                remote_config = self.get_remote_config(server_to_agent)
+                                self.update_conf_cb(remote_config)
+                            except Exception:
+                                # Catch exception and don't update the config
+                                # 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.resource_attributes = utils.parse_first_message_to_resource_attributes(sdk_config, opamp_logger)
                     self.signals = utils.parse_first_message_signals(sdk_config, opamp_logger)
-                    
+
                     # Send healthy message to OpAMP server
                     # opamp_logger.info("Reporting healthy to OpAMP server...")
                     agent_health = self.get_agent_health(component_health=True, status=AgentHealthStatus.HEALTHY.value)
                     self.send_agent_to_server_message(opamp_pb2.AgentToServer(health=agent_health))
-                    
+
                     # Return if the first message was successfully sent
                     return
-            
+
             except Exception as e:
                 # opamp_logger.error(f"Attempt {attempt}/{max_retries} failed. Error sending full state to OpAMP server: {e}")
                 pass
-            
+
             if attempt < max_retries:
                 time.sleep(delay)
-        
+
         # If all attempts failed, raise exception before starting the worker
         raise Exception(f"Error sending first message to OpAMP server after {max_retries} attempts")
 
@@ -149,28 +164,86 @@ class OpAMPHTTPClient:
                 try:
                     server_to_agent = self.send_heartbeat()
                     if self.update_remote_config_status(server_to_agent):
-                        # opamp_logger.info("Remote config updated, applying changes...")
-                        pass
-                        # TODO: implement changes based on the remote config
+                        if server_to_agent.HasField("remote_config") and self.update_conf_cb:
+                            try:
+                                remote_config = self.get_remote_config(server_to_agent)
+                                self.update_conf_cb(remote_config)
+                            except Exception:
+                                # Catch exception and don't update the config
+                                # The default config is preloaded when the EBPFSpanProcessor is initialized
+                                pass
 
                     if server_to_agent.flags & opamp_pb2.ServerToAgentFlags_ReportFullState:
                         # opamp_logger.info("Received request to report full state")
-                        
+
                         agent_description = self.get_agent_description()
                         agent_health = self.get_agent_health(component_health=True, status=AgentHealthStatus.HEALTHY.value)
                         agent_to_server = opamp_pb2.AgentToServer(agent_description=agent_description, health=agent_health)
-                        
+
                         server_to_agent = self.send_agent_to_server_message(agent_to_server)
-                        
-                        self.update_remote_config_status(server_to_agent)
-                
+
+                        if self.update_remote_config_status(server_to_agent):
+                            if server_to_agent.HasField("remote_config") and self.update_conf_cb:
+                                try:
+                                    remote_config = self.get_remote_config(server_to_agent)
+                                    self.update_conf_cb(remote_config)
+                                except Exception:
+                                    # Catch exception and don't update the config
+                                    # 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}")
                     pass
                 self.condition.wait(30)
 
+    def get_remote_config(self, message) -> dict:
+        """
+        Given a Protobuf message with a 'remote_config' field,
+        decode all bytes and base64-encoded subfields into a clean Python dict.
+        """
+        proto_dict = MessageToDict(message, preserving_proto_field_name=True)
+
+        remote_config = proto_dict.get("remote_config")
+        if not remote_config:
+            raise ValueError("No 'remote_config' field found in the provided message.")
+
+        config_map = remote_config.get("config", {}).get("config_map", {})
+        if not config_map:
+            raise ValueError("No 'config_map' found inside 'remote_config'.")
+
+        decoded_map = {}
+
+        for key, item in config_map.items():
+            body_base64 = item.get("body")
+            content_type = item.get("content_type")
+
+            if not body_base64:
+                decoded_map[key] = None
+                continue
+
+            try:
+                body_bytes = base64.b64decode(body_base64)
+            except Exception as e:
+                raise ValueError(f"Failed to base64 decode body for key {key}: {e}")
+
+            if content_type == "application/json":
+                try:
+                    body_json = json.loads(body_bytes.decode('utf-8'))
+                    decoded_map[key] = body_json
+                except Exception as e:
+                    raise ValueError(f"Failed to JSON-decode body for key {key}: {e}")
+            else:
+                # If not JSON, just keep it as raw bytes
+                decoded_map[key] = body_bytes
+
+        inner = decoded_map.get("", None)
+        if inner is None:
+            return Config() # Return default values for config
+        return from_dict(Config, inner)
+
     def send_heartbeat(self) -> opamp_pb2.ServerToAgent: # type: ignore
-        # opamp_logger.debug("Sending heartbeat to OpAMP server...") 
+        # 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)
@@ -179,23 +252,23 @@ class OpAMPHTTPClient:
             pass
 
     def get_agent_description(self) -> opamp_pb2.AgentDescription: # type: ignore
-        # The "DISABLE_OPAMP_CLIENT" environment variable is defined only in our VMs environments. 
+        # 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.
         #
-        # - If "DISABLE_OPAMP_CLIENT" is set to "true", it indicates that the service is running in a VM, 
+        # - If "DISABLE_OPAMP_CLIENT" is set to "true", it indicates that the service is running in a VM,
         #   so we use "PROCESS_PID" for identification.
-        # - Otherwise, the service is assumed to be running in a K8s environment, 
+        # - Otherwise, the service is assumed to be running in a K8s environment,
         #   and we use "PROCESS_VPID" instead.
         #
         # This ensures the correct process identification mechanism is applied based on the runtime environment.
 
         # Add additional attributes from environment variables
-                
+
         if os.getenv("DISABLE_OPAMP_CLIENT", "false").strip().lower() == "true":
             process_id_key = ResourceAttributes.PROCESS_PID
         else:
             process_id_key = PROCESS_VPID
-                        
+
         identifying_attributes = [
             anyvalue_pb2.KeyValue(
                 key=ResourceAttributes.SERVICE_INSTANCE_ID,
@@ -221,15 +294,15 @@ class OpAMPHTTPClient:
                         value=anyvalue_pb2.AnyValue(string_value=value)
                     )
                 )
-        
+
         return opamp_pb2.AgentDescription(
             identifying_attributes=identifying_attributes,
             non_identifying_attributes=[]
         )
-        
+
     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(
         )
@@ -239,24 +312,24 @@ class OpAMPHTTPClient:
             health.last_error = last_error
         if status is not None:
             health.status = status
-            
+
         return health
-    
-    
+
+
     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    
+        message.sequence_num = self.next_sequence_num
         if self.remote_config_status:
             message.remote_config_status.CopyFrom(self.remote_config_status)
-    
+
         self.next_sequence_num += 1
         message_bytes = message.SerializeToString()
-        
+
         headers = {
             "Content-Type": "application/x-protobuf",
         }
-        
+
         try:
             agent_message = attach(set_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY, True))
             response = requests_odigos.post(self.server_url, data=message_bytes, headers=headers, timeout=5)
@@ -269,7 +342,7 @@ class OpAMPHTTPClient:
             return opamp_pb2.ServerToAgent()
         finally:
             detach(agent_message)
-        
+
         server_to_agent = opamp_pb2.ServerToAgent()
         try:
             server_to_agent.ParseFromString(response.content)
@@ -277,19 +350,19 @@ class OpAMPHTTPClient:
             # opamp_logger.error(f"Error parsing response from OpAMP server: {e}")
             return opamp_pb2.ServerToAgent()
         return server_to_agent
-        
+
     def mandatory_env_vars_set(self):
         mandatory_env_vars = {
             "ODIGOS_OPAMP_SERVER_HOST": self.server_host,
         }
-        
+
         for env_var, value in mandatory_env_vars.items():
             if not value:
                 # opamp_logger.error(f"{env_var} environment variable not set")
                 return False
-        
-        return True        
-    
+
+        return True
+
     def shutdown(self, custom_failure_message: str = None, component_health: bool = False):
         self.running = False
         # opamp_logger.info("Sending agent disconnect message to OpAMP server...")
@@ -298,22 +371,24 @@ class OpAMPHTTPClient:
         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)
-        
+
         with self.condition:
             self.condition.notify_all()
         self.client_thread.join()
-        
+
         self.send_agent_to_server_message(disconnect_message)
-        
+
     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)
             self.remote_config_status = remote_config_status
             return True
-        
         return False
 
+    def register_config_update_cb(self, cb) -> None:
+        self.update_conf_cb = cb
+
 
 # Mock client class for non-OpAMP installations
 # This class simulates the OpAMP client when the OpAMP server is not available.
@@ -325,4 +400,4 @@ class MockOpAMPClient:
         event.set()
 
     def shutdown(self, custom_failure_message=None):
-        pass
+        pass

{odigos_opentelemetry_python-1.0.45 → odigos_opentelemetry_python-1.0.46}/opamp/utils.py

@@ -12,28 +12,28 @@ def get_sdk_config(config_map):
         return json.loads(config_map["SDK"].body)
     except json.JSONDecodeError:
         return {}
-    
+
 
 def parse_first_message_to_resource_attributes(sdk_config, logger: logging.Logger) -> dict: # type: ignore
     '''
     Parses remote resource attributes from the SDK config.
     '''
-    
+
     remote_resource_attributes = sdk_config.get('remoteResourceAttributes', [])
-    
+
     if not remote_resource_attributes:
         # logger.error('missing "remoteResourceAttributes" section in OpAMP server remote config on first server to agent message')
         return {}
-    
+
     return {item['key']: item['value'] for item in remote_resource_attributes}
 
 def parse_first_message_signals(sdk_config, logger: logging.Logger): # 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),
-    }
+    }

{odigos_opentelemetry_python-1.0.45 → odigos_opentelemetry_python-1.0.46}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="odigos-opentelemetry-python",
-    version="1.0.45",
+    version="1.0.46",
     description="Odigos Initializer for Python OpenTelemetry Components",
     author="Tamir David",
     author_email="tamir@odigos.io",