rebrandly-otel 0.1.14__tar.gz → 0.1.16__tar.gz

{rebrandly_otel-0.1.14 → rebrandly_otel-0.1.16}/PKG-INFO

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

{rebrandly_otel-0.1.14 → rebrandly_otel-0.1.16}/rebrandly_otel.egg-info/PKG-INFO

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

{rebrandly_otel-0.1.14 → rebrandly_otel-0.1.16}/setup.py

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

{rebrandly_otel-0.1.14 → rebrandly_otel-0.1.16}/src/rebrandly_otel.py

@@ -1,6 +1,7 @@
 # rebrandly_otel.py
 """
 Rebrandly OpenTelemetry SDK - Simplified instrumentation for Rebrandly services.
+Updated for consistency with Node.js SDK
 """
 import time
 import psutil
@@ -99,8 +100,6 @@ 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,
@@ -132,6 +131,7 @@ class RebrandlyOTEL:
 
                 # Handle context extraction from AWS events
                 token = None
+
                 if not skip_aws_link and event and isinstance(event, dict) and 'Records' in event:
                     first_record = event['Records'][0] if event['Records'] else None
                     if first_record:
@@ -160,11 +160,10 @@ class RebrandlyOTEL:
                             from opentelemetry import propagate, context as otel_context
                             extracted_context = propagate.extract(carrier)
                             token = otel_context.attach(extracted_context)
-                            span_attributes['message.has_trace_context'] = True
 
                 result = None
                 try:
-                    # Increment invocation counter
+                    # Increment invocation counter with standardized metric name
                     self.meter.GlobalMetrics.invocations.add(1, {'function': span_name})
 
                     # Create and execute within span
@@ -173,26 +172,63 @@ class RebrandlyOTEL:
                             attributes=span_attributes,
                             kind=kind
                     ) as span:
-                        # Add invocation start event
-                        span.add_event("lambda.invocation.start", {
+                        # Add invocation start event with standardized attributes
+                        start_event_attrs = {
                             'event.type': type(event).__name__ if event else 'None'
-                        })
+                        }
+
+                        # Add records count if present
+                        if event and isinstance(event, dict) and 'Records' in event:
+                            start_event_attrs['event.records'] = f"{len(event['Records'])}"
+
+                        span.add_event("lambda.invocation.start", start_event_attrs)
 
                         # Execute handler
                         result = func(event, lambda_context)
 
-                        # Process result
-                        self._process_lambda_result(result, span, span_name)
+                        # Process result with standardized attributes
+                        success = True
+                        complete_event_attrs = {}
+
+                        if isinstance(result, dict) and 'statusCode' in result:
+                            span.set_attribute("http.status_code", result['statusCode'])
+                            complete_event_attrs['status_code'] = result['statusCode']
+
+                            # Set span status based on HTTP status code
+                            if result['statusCode'] >= 400:
+                                success = False
+                                span.set_status(Status(StatusCode.ERROR, f"HTTP {result['statusCode']}"))
+                            else:
+                                span.set_status(Status(StatusCode.OK))
+                        else:
+                            span.set_status(Status(StatusCode.OK))
+
+                        # Add completion event with success indicator
+                        complete_event_attrs['success'] = success
+                        span.add_event("lambda.invocation.complete", complete_event_attrs)
+
+                        # Increment success counter with standardized metric
+                        self.meter.GlobalMetrics.successful_invocations.add(1, {'function': span_name})
 
                     return result
 
                 except Exception as e:
-                    # Increment error counter
+                    # Increment error counter with standardized metric
                     self.meter.GlobalMetrics.error_invocations.add(1, {
                         'function': span_name,
                         'error': type(e).__name__
                     })
 
+                    # Add failed completion event with error attribute (THIS IS THE KEY ADDITION)
+                    span.add_event("lambda.invocation.complete", {
+                        'success': False,
+                        'error': type(e).__name__
+                    })
+
+                    # Record the exception in the span
+                    span.record_exception(e)
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+
                     # Log error
                     self.logger.logger.error(f"Lambda execution failed: {e}", exc_info=True)
                     raise
@@ -203,81 +239,68 @@ class RebrandlyOTEL:
                         from opentelemetry import context as otel_context
                         otel_context.detach(token)
 
-                    # Record duration
+                    # Record duration with standardized metric
                     duration = (datetime.now() - start_time).total_seconds() * 1000
                     self.meter.GlobalMetrics.duration.record(duration, {'function': span_name})
 
                     # Force flush if enabled
                     if auto_flush:
-                        self.logger.logger.info(f"[OTEL] Lambda '{span_name}' completed in {duration:.2f}ms, flushing...")
+                        self.logger.logger.info(f"[Rebrandly OTEL] Lambda '{span_name}' completed in {duration:.2f}ms, flushing...")
                         flush_success = self.force_flush(timeout_millis=1000)
                         if not flush_success:
-                            self.logger.logger.warning("[OTEL] Force flush may not have completed fully")
+                            self.logger.logger.warning("[Rebrandly OTEL] Force flush may not have completed fully")
 
             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,
-                       kind: SpanKind = SpanKind.CONSUMER,
-                       auto_flush: bool = True):
+                            name: Optional[str] = None,
+                            attributes: Optional[Dict[str, Any]] = None,
+                            kind: SpanKind = SpanKind.CONSUMER,
+                            auto_flush: bool = True):
         """
-        require a record object parameter to the function
+        Decorator for AWS message handlers (SQS/SNS record processing).
+        Requires a record object parameter to the function.
         """
         def decorator(func):
             @functools.wraps(func)
             def wrapper(record=None, *args, **kwargs):
                 # Determine span name
-                span_name = name or f"lambda.{func.__name__}"
+                span_name = name or f"message.{func.__name__}"
                 start_func = datetime.now()
 
                 # Build span attributes
                 span_attributes = attributes or {}
+                span_attributes['messaging.operation'] = 'process'
 
                 result = None
                 try:
-                    # Increment invocations counter
-                    print('XXX 2')
+                    # Increment invocations counter with standardized metric
                     self.meter.GlobalMetrics.invocations.add(1, {'handler': span_name})
 
                     # Create span and execute function
                     span_function = self.span
-                    if record is not None and 'MessageAttributes' in record:
+                    if record is not None and ('MessageAttributes' in record or 'messageAttributes' in record):
                         span_function = self.aws_message_span
 
                     with span_function(span_name, message=record, attributes=span_attributes, kind=kind) as span_context:
+                        # Add processing start event with standardized name
+                        span_context.add_event("message.processing.start", {})
+
                         # Execute the actual handler function
                         result = func(record, *args, **kwargs)
 
-                        # Add result attributes if applicable
+                        # Process result
+                        success = True
+                        complete_event_attrs = {}
+
                         if result and isinstance(result, dict):
                             if 'statusCode' in result:
-                                span_context.set_attribute("handler.status_code", result['statusCode'])
+                                span_context.set_attribute("http.status_code", result['statusCode'])
 
                                 # Set span status based on status code
                                 if result['statusCode'] >= 400:
+                                    success = False
                                     span_context.set_status(
                                         Status(StatusCode.ERROR, f"Handler returned {result['statusCode']}")
                                     )
@@ -286,32 +309,49 @@ class RebrandlyOTEL:
 
                             # Add custom result attributes if present
                             if 'processed' in result:
-                                span_context.set_attribute("handler.processed", result['processed'])
+                                complete_event_attrs['processed'] = result['processed']
+                                span_context.set_attribute("message.processed", result['processed'])
                             if 'skipped' in result:
-                                span_context.set_attribute("handler.skipped", result['skipped'])
+                                complete_event_attrs['skipped'] = result['skipped']
+                                span_context.set_attribute("message.skipped", result['skipped'])
+                        else:
+                            span_context.set_status(Status(StatusCode.OK))
 
-                        # Add completion event
-                        span_context.add_event("lambda.invocation.complete", attributes={
-                            "handler.success": True
-                        })
+                        # Add completion event with standardized name
+                        complete_event_attrs['success'] = success
+                        span_context.add_event("message.processing.complete", complete_event_attrs)
 
-                        # Increment success counter
+                        # Increment success counter with standardized metric
                         self.meter.GlobalMetrics.successful_invocations.add(1, {'handler': span_name})
 
                         return result
 
                 except Exception as e:
-                    # Increment error counter
-                    self.meter.GlobalMetrics.error_invocations.add(1, {'handler': span_name, 'error': type(e).__name__})
+                    # Increment error counter with standardized metric
+                    self.meter.GlobalMetrics.error_invocations.add(1, {
+                        'handler': span_name,
+                        'error': type(e).__name__
+                    })
 
                     # Record the exception in the span
-                    span_context.record_exception(e)
-                    span_context.set_status(Status(StatusCode.ERROR, str(e)))
+                    if 'span_context' in locals():
+                        span_context.record_exception(e)
+                        span_context.set_status(Status(StatusCode.ERROR, str(e)))
+
+                        # Add failed processing event
+                        span_context.add_event("message.processing.complete", {
+                            'success': False,
+                            'error': type(e).__name__
+                        })
 
                     # Re-raise the exception
                     raise
 
                 finally:
+                    # Record duration with standardized metric
+                    duration = (datetime.now() - start_func).total_seconds() * 1000
+                    self.meter.GlobalMetrics.duration.record(duration, {'handler': span_name})
+
                     if auto_flush:
                         self.force_flush(start_datetime=start_func)
 
@@ -324,6 +364,7 @@ class RebrandlyOTEL:
         This is CRITICAL for Lambda functions to ensure data is sent before function freezes.
 
         Args:
+            start_datetime: Optional start time for system metrics capture
             timeout_millis: Maximum time to wait for flush in milliseconds
 
         Returns:
@@ -334,14 +375,15 @@ class RebrandlyOTEL:
         if start_datetime is not None:
             end_func = datetime.now()
             duration = (end_func - start_datetime).total_seconds() * 1000
-            cpu_percent = psutil.cpu_percent(interval=1)
+            cpu_percent = psutil.cpu_percent(interval=0.1)  # Shorter interval for Lambda
             memory = psutil.virtual_memory()
 
             # Record metrics using standardized names
             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"Function duration: {duration}ms, Memory usage: {memory.percent}%, CPU usage: {cpu_percent}%")
+
+            print(f"Function duration: {duration}ms, Memory usage: {memory.percent}%, CPU usage: {cpu_percent}%")
 
         try:
             # Flush traces
@@ -379,9 +421,8 @@ class RebrandlyOTEL:
                 self._meter.shutdown()
             if self._logger:
                 self._logger.shutdown()
-            print("[OTEL] Shutdown completed")
         except Exception as e:
-            print(f"[OTEL] Error during shutdown: {e}")
+            print(f"[Rebrandly OTEL] Error during shutdown: {e}")
 
     def _detect_lambda_trigger(self, event: Any) -> str:
         """Detect Lambda trigger type from event."""
@@ -455,6 +496,7 @@ class RebrandlyOTEL:
         from opentelemetry import trace, context as otel_context
 
         combined_attributes = attributes or {}
+        combined_attributes['messaging.operation'] = 'process'
 
         # Extract message attributes for linking/attributes
         if message and isinstance(message, dict):
@@ -463,16 +505,11 @@ class RebrandlyOTEL:
                 sns_msg = message['Sns']
                 if 'MessageId' in sns_msg:
                     combined_attributes['messaging.message_id'] = sns_msg['MessageId']
+                if 'Subject' in sns_msg:
+                    combined_attributes['messaging.sns.subject'] = sns_msg['Subject']
                 if 'TopicArn' in sns_msg:
                     combined_attributes['messaging.destination'] = sns_msg['TopicArn']
-                combined_attributes['messaging.system'] = 'aws_sns'
-
-                # 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
+                combined_attributes['messaging.system'] = 'sns'
 
             elif 'messageId' in message:
                 # SQS message
@@ -480,18 +517,11 @@ class RebrandlyOTEL:
                 if 'eventSource' in message:
                     combined_attributes['messaging.system'] = message['eventSource']
 
-                # 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']
 
+
         # 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(