rebrandly-otel 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

rebrandly_otel/rebrandly_otel.py

@@ -101,101 +101,115 @@ class RebrandlyOTEL:
 
     # 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,
-                       kind: SpanKind = SpanKind.CONSUMER,
+                       kind: SpanKind = SpanKind.SERVER,
                        auto_flush: bool = True,
-                       skip_aws_link: bool = True):
+                       skip_aws_link: bool = False):
         """
         Decorator specifically for Lambda handlers with automatic flushing.
         """
         def decorator(func):
             @functools.wraps(func)
-            def wrapper(event=None, context=None):
+            def wrapper(event=None, lambda_context=None):
                 # Determine span name
                 span_name = name or f"lambda.{func.__name__}"
-                start_func = datetime.now()
+                start_time = datetime.now()
 
                 # Build span attributes
                 span_attributes = attributes or {}
-
                 span_attributes['faas.trigger'] = self._detect_lambda_trigger(event)
 
                 # Add Lambda-specific attributes if context is available
-                if context is not None:
+                if lambda_context is not None:
                     span_attributes.update({
-                        "faas.execution": getattr(context, 'aws_request_id', 'unknown'),
-                        "faas.id": getattr(context, 'function_name', 'unknown'),
-                        "cloud.provider": "aws",
-                        "cloud.platform": "aws_lambda"
+                        "faas.execution": getattr(lambda_context, 'aws_request_id', 'unknown'),
+                        "faas.id": getattr(lambda_context, 'function_arn', 'unknown'),
+                        "faas.name": getattr(lambda_context, 'function_name', 'unknown'),
+                        "faas.version": getattr(lambda_context, 'function_version', 'unknown')
                     })
 
+                # 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:
+                        carrier = {}
+
+                        # Extract from SQS
+                        if 'MessageAttributes' in first_record:
+                            for key, value in first_record['MessageAttributes'].items():
+                                if isinstance(value, dict) and 'StringValue' in value:
+                                    carrier[key] = value['StringValue']
+
+                        # Extract from SNS
+                        elif 'Sns' in first_record and 'MessageAttributes' in first_record['Sns']:
+                            for key, value in first_record['Sns']['MessageAttributes'].items():
+                                if isinstance(value, dict):
+                                    if 'Value' in value:
+                                        carrier[key] = value['Value']
+                                    elif 'StringValue' in value:
+                                        carrier[key] = value['StringValue']
+
+                        # Attach extracted context
+                        if carrier:
+                            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 invocations counter
+                    # Increment invocation counter
                     self.meter.GlobalMetrics.invocations.add(1, {'function': span_name})
 
-                    # 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]
+                    # Create and execute within span
+                    with self.tracer.start_span(
+                            name=span_name,
+                            attributes=span_attributes,
+                            kind=kind
+                    ) as span:
+                        # Add invocation start event
+                        span.add_event("lambda.invocation.start", {
+                            'event.type': type(event).__name__ if event else 'None'
+                        })
+
+                        # Execute handler
+                        result = func(event, lambda_context)
 
-                        # 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)
+                        # Process result
+                        self._process_lambda_result(result, span, 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__})
+                    self.meter.GlobalMetrics.error_invocations.add(1, {
+                        'function': span_name,
+                        'error': type(e).__name__
+                    })
 
-                    # Log error with context
+                    # Log error
                     self.logger.logger.error(f"Lambda execution failed: {e}", exc_info=True)
                     raise
 
                 finally:
+                    # Always detach context if we attached it
+                    if token is not None:
+                        from opentelemetry import context as otel_context
+                        otel_context.detach(token)
+
                     # Record duration
-                    duration = (datetime.now() - start_func).total_seconds() * 1000
+                    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.force_flush(start_datetime=start_func)
+                        self.logger.logger.info(f"[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")
 
             return wrapper
         return decorator

{rebrandly_otel-0.1.11.dist-info → rebrandly_otel-0.1.13.dist-info}/METADATA

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

{rebrandly_otel-0.1.11.dist-info → rebrandly_otel-0.1.13.dist-info}/RECORD

@@ -2,10 +2,10 @@ rebrandly_otel/__init__.py,sha256=AHcEKWq4KRafIF_x_Y8jiIQ5crNG1nbEwdnlGaEP6js,28
 rebrandly_otel/logs.py,sha256=92jaxzI5hCHnKHu3lsSAa7K_SPHQgL46AlQUESsYNds,3724
 rebrandly_otel/metrics.py,sha256=57jwrn8e1u66BOO7fcFrmtE3Rpt4VDixG9I78K-zrUU,8537
 rebrandly_otel/otel_utils.py,sha256=uJmfz2NspSnTVJXGKoaLUl1CYb0ow6VHKjmg2d_rdwg,1704
-rebrandly_otel/rebrandly_otel.py,sha256=LwzBVY67N12X--8js8yFixusFs7T--1BVog0jOVds4k,20790
+rebrandly_otel/rebrandly_otel.py,sha256=cnWTDMH-z4n32HTxCbML0zedKhG5ZKPtkej5sL1epok,21438
 rebrandly_otel/traces.py,sha256=v582WtJv3t4Bn92vlDyZouibHtgWNxdRo_XmQCmSOEA,7126
-rebrandly_otel-0.1.11.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
-rebrandly_otel-0.1.11.dist-info/METADATA,sha256=aRJJR4nhuJiocpBS1hpXuIWpUv-KEX0R_b3wkq7ns3g,9628
-rebrandly_otel-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rebrandly_otel-0.1.11.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
-rebrandly_otel-0.1.11.dist-info/RECORD,,
+rebrandly_otel-0.1.13.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
+rebrandly_otel-0.1.13.dist-info/METADATA,sha256=Xu5Rxr80l_mB6Hx489zddCbWDqNKxcr6klUzujSV-4Y,9628
+rebrandly_otel-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rebrandly_otel-0.1.13.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
+rebrandly_otel-0.1.13.dist-info/RECORD,,