rebrandly-otel 0.1.9__tar.gz → 0.1.11__tar.gz

{rebrandly_otel-0.1.9 → rebrandly_otel-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.9
+Version: 0.1.11
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano

{rebrandly_otel-0.1.9 → rebrandly_otel-0.1.11}/rebrandly_otel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.9
+Version: 0.1.11
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano

{rebrandly_otel-0.1.9 → rebrandly_otel-0.1.11}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="rebrandly_otel",
-    version="0.1.9",
+    version="0.1.11",
     author="Antonio Romano",
     author_email="antonio@rebrandly.com",
     description="Python OTEL wrapper by Rebrandly",

{rebrandly_otel-0.1.9 → rebrandly_otel-0.1.11}/src/rebrandly_otel.py

@@ -99,6 +99,9 @@ class RebrandlyOTEL:
             return wrapper
         return decorator
 
+    # Fix for the lambda_handler method in rebrandly_otel.py
+    # Replace the lambda_handler method (around line 132) with this fixed version:
+
     def lambda_handler(self,
                        name: Optional[str] = None,
                        attributes: Optional[Dict[str, Any]] = None,
@@ -107,22 +110,6 @@ class RebrandlyOTEL:
                        skip_aws_link: bool = True):
         """
         Decorator specifically for Lambda handlers with automatic flushing.
-
-        Args:
-            name: Optional span name (defaults to 'lambda.{function_name}')
-            attributes: Additional span attributes
-            kind: Span kind (defaults to SERVER)
-            auto_flush: If True, automatically flush after handler completes
-
-        Usage:
-            @lambda_handler()
-            def my_handler(event, context): ...
-
-            @lambda_handler(name="custom_span_name")
-            def my_handler(event, context): ...
-
-            @lambda_handler(name="my_span", attributes={"env": "prod"})
-            def my_handler(event, context): ...
         """
         def decorator(func):
             @functools.wraps(func)
@@ -150,50 +137,90 @@ class RebrandlyOTEL:
                     # Increment invocations counter
                     self.meter.GlobalMetrics.invocations.add(1, {'function': span_name})
 
-                    # Create span and execute function
-                    record = None
-                    span_function = self.span
-                    if not skip_aws_link and event is not None and 'Records' in event and len(event['Records']) > 0 and 'MessageAttributes' in event['Records'][0]:
-                        span_function = self.aws_message_span
-                        record = event['Records'][0]
-
-                    with span_function(span_name, message=record, attributes=span_attributes, kind=kind) as span_context:
-                        # Add event type as span event
-                        if event is not None:
-                            span_context.add_event("lambda.invocation.start", attributes={"event.type": type(event).__name__})
-
-                            result = func(event, context)
-                        else:
-                            result = func()
-
-                        # Add result information if applicable
-                        if isinstance(result, dict):
-                            if 'statusCode' in result:
-                                span_context.set_attribute("http.status_code", result['statusCode'])
-                                # Set span status based on HTTP status code
-                                if result['statusCode'] >= 400:
-                                    span_context.set_status(Status(StatusCode.ERROR, f"HTTP {result['statusCode']}"))
-                                else:
-                                    span_context.set_status(Status(StatusCode.OK))
-
-                        # Increment success counter
-                        self.meter.GlobalMetrics.successful_invocations.add(1, {'function': span_name})
-
-                        return result
+                    # Determine if we should extract context from AWS message
+                    extracted_context = None
+                    if not skip_aws_link and event is not None and 'Records' in event and len(event['Records']) > 0:
+                        first_record = event['Records'][0]
+
+                        # Check different message formats
+                        if 'messageAttributes' in first_record or 'MessageAttributes' in first_record:
+                            # SQS format
+                            extracted_context = self.extract_context(first_record)
+                        elif 'Sns' in first_record and 'MessageAttributes' in first_record['Sns']:
+                            # SNS format
+                            extracted_context = self.extract_context(first_record)
+
+                    # Create span - use extracted context if available
+                    if extracted_context:
+                        token = self.attach_context(extracted_context)
+                        try:
+                            with self.span(span_name, attributes=span_attributes, kind=kind) as span_context:
+                                # Add event type as span event
+                                if event is not None:
+                                    span_context.add_event("lambda.invocation.start",
+                                                           attributes={"event.type": type(event).__name__})
+
+                                result = func(event, context) if event is not None else func()
+
+                                # Handle result
+                                self._process_lambda_result(result, span_context, span_name)
+                        finally:
+                            self.detach_context(token)
+                    else:
+                        # No context extraction needed
+                        with self.span(span_name, attributes=span_attributes, kind=kind) as span_context:
+                            # Add event type as span event
+                            if event is not None:
+                                span_context.add_event("lambda.invocation.start",
+                                                       attributes={"event.type": type(event).__name__})
+
+                            result = func(event, context) if event is not None else func()
+
+                            # Handle result
+                            self._process_lambda_result(result, span_context, span_name)
+
+                    return result
 
                 except Exception as e:
                     # Increment error counter
                     self.meter.GlobalMetrics.error_invocations.add(1, {'function': span_name, 'error': type(e).__name__})
+
+                    # Log error with context
+                    self.logger.logger.error(f"Lambda execution failed: {e}", exc_info=True)
                     raise
 
                 finally:
+                    # Record duration
+                    duration = (datetime.now() - start_func).total_seconds() * 1000
+                    self.meter.GlobalMetrics.duration.record(duration, {'function': span_name})
+
                     if auto_flush:
-                        self.logger.logger.info(f"[OTEL] Lambda handler '{span_name}' completed, flushing telemetry...")
                         self.force_flush(start_datetime=start_func)
 
             return wrapper
         return decorator
 
+    def _process_lambda_result(self, result, span_context, span_name):
+        """Helper method to process Lambda result and update span accordingly"""
+        if isinstance(result, dict):
+            if 'statusCode' in result:
+                span_context.set_attribute("http.status_code", result['statusCode'])
+                # Set span status based on HTTP status code
+                if result['statusCode'] >= 400:
+                    span_context.set_status(Status(StatusCode.ERROR, f"HTTP {result['statusCode']}"))
+                else:
+                    span_context.set_status(Status(StatusCode.OK))
+
+            # Add completion event
+            span_context.add_event("lambda.invocation.complete",
+                                   attributes={"success": result.get('statusCode', 200) < 400})
+        else:
+            span_context.set_status(Status(StatusCode.OK))
+            span_context.add_event("lambda.invocation.complete", attributes={"success": True})
+
+        # Increment success counter
+        self.meter.GlobalMetrics.successful_invocations.add(1, {'function': span_name})
+
     def aws_message_handler(self,
                        name: Optional[str] = None,
                        attributes: Optional[Dict[str, Any]] = None,
@@ -269,7 +296,6 @@ class RebrandlyOTEL:
 
                 finally:
                     if auto_flush:
-                        self.logger.logger.info(f"[OTEL] Lambda handler '{span_name}' completed, flushing telemetry...")
                         self.force_flush(start_datetime=start_func)
 
             return wrapper
@@ -298,7 +324,7 @@ class RebrandlyOTEL:
             self.meter.GlobalMetrics.duration.record(duration, {'source': 'force_flush'})
             self.meter.GlobalMetrics.memory_usage_bytes.set(memory.used)
             self.meter.GlobalMetrics.cpu_usage_percentage.set(cpu_percent)
-            self.logger.logger.info(f"[OTEL] Function duration: {duration}ms, Memory usage: {memory.percent}%, CPU usage: {cpu_percent}%")
+            self.logger.logger.info(f"Function duration: {duration}ms, Memory usage: {memory.percent}%, CPU usage: {cpu_percent}%")
 
         try:
             # Flush traces
@@ -336,9 +362,9 @@ class RebrandlyOTEL:
                 self._meter.shutdown()
             if self._logger:
                 self._logger.shutdown()
-            self.logger.logger.info("[OTEL] Shutdown completed")
+            print("[OTEL] Shutdown completed")
         except Exception as e:
-            self.logger.logger.info(f"[OTEL] Error during shutdown: {e}")
+            print(f"[OTEL] Error during shutdown: {e}")
 
     def _detect_lambda_trigger(self, event: Any) -> str:
         """Detect Lambda trigger type from event."""
@@ -407,43 +433,15 @@ class RebrandlyOTEL:
                          message: Dict[str, Any]=None,
                          attributes: Optional[Dict[str, Any]] = None,
                          kind: SpanKind = SpanKind.CONSUMER):
-        """Create span from AWS message with extracted context."""
-        # Extract context from the message if it contains trace context
-        token = None
-        if message and isinstance(message, dict):
-            carrier = {}
+        """Create span from AWS message - properly handling trace context."""
+
+        from opentelemetry import trace, context as otel_context
 
-            # Check for trace context in different possible locations
-            if 'MessageAttributes' in message:
-                # SQS format
-                for key, value in message.get('MessageAttributes', {}).items():
-                    if isinstance(value, dict) and 'StringValue' in value:
-                        carrier[key] = value['StringValue']
-            elif 'Sns' in message and 'MessageAttributes' in message['Sns']:
-                # SNS format - MessageAttributes are nested under 'Sns'
-                for key, value in message['Sns'].get('MessageAttributes', {}).items():
-                    if isinstance(value, dict):
-                        # SNS uses 'Value' instead of 'StringValue'
-                        if 'Value' in value:
-                            carrier[key] = value['Value']
-                        elif 'StringValue' in value:
-                            carrier[key] = value['StringValue']
-            elif 'messageAttributes' in message:
-                # Alternative format
-                for key, value in message.get('messageAttributes', {}).items():
-                    if isinstance(value, dict) and 'stringValue' in value:
-                        carrier[key] = value['stringValue']
-
-            # If we found trace context, attach it
-            if carrier:
-                token = self.attach_context(carrier)
-
-        # Create a span with the potentially extracted context
         combined_attributes = attributes or {}
 
-        # Add message-specific attributes
+        # Extract message attributes for linking/attributes
         if message and isinstance(message, dict):
-            # Add SNS-specific attributes
+            # Add message-specific attributes
             if 'Sns' in message:
                 sns_msg = message['Sns']
                 if 'MessageId' in sns_msg:
@@ -451,24 +449,40 @@ class RebrandlyOTEL:
                 if 'TopicArn' in sns_msg:
                     combined_attributes['messaging.destination'] = sns_msg['TopicArn']
                 combined_attributes['messaging.system'] = 'aws_sns'
-            # Add SQS-specific attributes
+
+                # Check for trace context in SNS
+                if 'MessageAttributes' in sns_msg:
+                    for key, value in sns_msg['MessageAttributes'].items():
+                        if key == 'traceparent' and 'Value' in value:
+                            combined_attributes['message.traceparent'] = value['Value']
+                            combined_attributes['message.has_trace_context'] = True
+
             elif 'messageId' in message:
+                # SQS message
                 combined_attributes['messaging.message_id'] = message['messageId']
                 if 'eventSource' in message:
                     combined_attributes['messaging.system'] = message['eventSource']
 
-            # Add common attributes
+                # Check for trace context in SQS
+                if 'MessageAttributes' in message or 'messageAttributes' in message:
+                    attrs = message.get('MessageAttributes') or message.get('messageAttributes', {})
+                    for key, value in attrs.items():
+                        if key == 'traceparent':
+                            tp_value = value.get('StringValue') or value.get('stringValue', '')
+                            combined_attributes['message.traceparent'] = tp_value
+                            combined_attributes['message.has_trace_context'] = True
+
             if 'awsRegion' in message:
                 combined_attributes['cloud.region'] = message['awsRegion']
 
-        try:
-            # Use the regular span method which properly handles context
-            with self.span(name, attributes=combined_attributes, kind=kind) as span:
-                yield span
-        finally:
-            # Detach context if we attached one
-            if token:
-                self.detach_context(token)
+        # Use the tracer's start_span method directly to ensure it works
+        # This creates a child span of whatever is currently active
+        with self.tracer.start_span(
+                name=name,
+                attributes=combined_attributes,
+                kind=kind
+        ) as span:
+            yield span
 
 
 # Create Singleton instance

{rebrandly_otel-0.1.9 → rebrandly_otel-0.1.11}/src/traces.py

@@ -93,6 +93,7 @@ class RebrandlyTracer:
                    attributes: Optional[Dict[str, Any]] = None,
                    kind: trace.SpanKind = trace.SpanKind.INTERNAL) -> ContextManager[Span]:
         """Start a new span as the current span."""
+        # Ensure we use the tracer to create a child span of the current span
         with self.tracer.start_as_current_span(
                 name,
                 attributes=attributes,