rebrandly-otel 0.1.14__py3-none-any.whl → 0.1.17__py3-none-any.whl

rebrandly_otel/__init__.py

@@ -1,5 +1,6 @@
 # src/__init__.py
 from .rebrandly_otel import *
+from .flask_support import *
 
 # Explicitly define what's available
 __all__ = [
@@ -12,5 +13,6 @@ __all__ = [
     'logger',
     'force_flush',
     'aws_message_handler',
-    'shutdown'
+    'shutdown',
+    'setup_flask'
 ]

rebrandly_otel/flask_support.py

@@ -0,0 +1,170 @@
+# flask_integration.py
+"""Flask integration for Rebrandly OTEL SDK."""
+from typing import TYPE_CHECKING
+from opentelemetry.trace import Status, StatusCode, SpanKind
+
+if TYPE_CHECKING:
+    from .rebrandly_otel import RebrandlyOTEL
+
+def setup_flask(otel: 'RebrandlyOTEL', app):
+    """
+    Setup Flask application with OTEL instrumentation.
+    
+    Example:
+        from flask import Flask
+        from rebrandly_otel import otel
+        from rebrandly_otel.flask_integration import setup_flask
+        
+        app = Flask(__name__)
+        setup_flask(otel, app)
+    """
+    app.before_request(lambda: app_before_request(otel))
+    app.after_request(lambda response: app_after_request(otel, response))
+    app.register_error_handler(Exception, lambda e: flask_error_handler(otel, e))
+    return app
+
+def app_before_request(otel: 'RebrandlyOTEL'):
+    """
+    Setup tracing for incoming Flask request.
+    To be used with Flask's before_request hook.
+    """
+    from flask import request
+
+    # Extract trace context from headers
+    headers = dict(request.headers)
+    token = otel.attach_context(headers)
+    request.trace_token = token
+
+    # Start span for request using start_as_current_span to make it the active span
+    span = otel.tracer.tracer.start_as_current_span(
+        f"{request.method} {request.path}",
+        attributes={
+            "http.method": request.method,
+            "http.url": request.url,
+            "http.path": request.path,
+            "http.scheme": request.scheme,
+            "http.host": request.host,
+            "http.user_agent": request.user_agent.string if request.user_agent else '',
+            "http.remote_addr": request.remote_addr,
+            "http.target": request.path,
+            "span.kind": "server"
+        },
+        kind=SpanKind.SERVER
+    )
+    # Store both the span context manager and the span itself
+    request.span_context = span
+    request.span = span.__enter__()  # This activates the span and returns the span object
+
+    # Log request start
+    otel.logger.logger.info(f"Request started: {request.method} {request.path}",
+                            extra={"http.method": request.method, "http.path": request.path})
+
+def app_after_request(otel: 'RebrandlyOTEL', response):
+    """
+    Cleanup tracing after Flask request completes.
+    To be used with Flask's after_request hook.
+    """
+    from flask import request
+
+    # Check if we have a span and it's still recording
+    if hasattr(request, 'span') and request.span.is_recording():
+        request.span.set_attribute("http.status_code", response.status_code)
+
+        # Set span status based on HTTP status code
+        if response.status_code >= 400:
+            request.span.set_status(Status(StatusCode.ERROR, f"HTTP {response.status_code}"))
+            # Record error metric
+            otel.meter.GlobalMetrics.error_invocations.add(1, {
+                "endpoint": request.path,
+                "method": request.method,
+                "status_code": response.status_code
+            })
+        else:
+            request.span.set_status(Status(StatusCode.OK))
+            # Record success metric
+            otel.meter.GlobalMetrics.successful_invocations.add(1, {
+                "endpoint": request.path,
+                "method": request.method
+            })
+
+        # Properly close the span context manager
+        if hasattr(request, 'span_context'):
+            request.span_context.__exit__(None, None, None)
+        else:
+            # Fallback if we don't have the context manager
+            request.span.end()
+
+    # Detach context
+    if hasattr(request, 'trace_token'):
+        otel.detach_context(request.trace_token)
+
+    # Log request completion
+    otel.logger.logger.info(f"Request completed: {response.status_code}",
+                            extra={"http.status_code": response.status_code})
+
+    # Record general invocation metric
+    otel.meter.GlobalMetrics.invocations.add(1, {
+        "endpoint": request.path,
+        "method": request.method
+    })
+
+    return response
+
+def flask_error_handler(otel: 'RebrandlyOTEL', exception):
+    """
+    Handle Flask exceptions and record them in the current span.
+    To be used with Flask's errorhandler decorator.
+    """
+    from flask import request, jsonify
+    from werkzeug.exceptions import HTTPException
+
+    # Determine the status code
+    if isinstance(exception, HTTPException):
+        status_code = exception.code
+    elif hasattr(exception, 'status_code'):
+        status_code = exception.status_code
+    elif hasattr(exception, 'code'):
+        status_code = exception.code if isinstance(exception.code, int) else 500
+    else:
+        status_code = 500
+
+    # Record exception in span if available and still recording
+    if hasattr(request, 'span') and request.span.is_recording():
+        request.span.set_attribute("http.status_code", status_code)
+        request.span.set_attribute("error.type", type(exception).__name__)
+
+        request.span.record_exception(exception)
+        request.span.set_status(Status(StatusCode.ERROR, str(exception)))
+        request.span.add_event("exception", {
+            "exception.type": type(exception).__name__,
+            "exception.message": str(exception),
+            "http.status_code": status_code
+        })
+
+        # Only close the span if it's still recording (not already ended)
+        if hasattr(request, 'span_context'):
+            request.span_context.__exit__(type(exception), exception, None)
+        else:
+            request.span.end()
+
+    # Log the error with status code
+    otel.logger.logger.error(f"Unhandled exception: {exception} (status: {status_code})",
+                             exc_info=True,
+                             extra={
+                                 "exception.type": type(exception).__name__,
+                                 "http.status_code": status_code
+                             })
+
+    # Record error metric with status code
+    otel.meter.GlobalMetrics.error_invocations.add(1, {
+        "endpoint": request.path if hasattr(request, 'path') else 'unknown',
+        "method": request.method if hasattr(request, 'method') else 'unknown',
+        "error": type(exception).__name__,
+        "status_code": status_code
+    })
+
+    # Return error response with the determined status code
+    return jsonify({
+        "error": str(exception),
+        "type": type(exception).__name__
+    }), status_code

rebrandly_otel/otel_utils.py

@@ -25,6 +25,17 @@ def create_resource(name: str = None, version: str = None) -> Resource:
     )
     return resource
 
+def get_package_version():
+    try:
+        from importlib.metadata import version, PackageNotFoundError  # Python 3.8+
+        return version('rebrandly_otel')
+    except ImportError:
+        try:
+            from importlib_metadata import version, PackageNotFoundError
+            return version('rebrandly_otel')
+        except:
+            return '?.0.1'
+
 
 def get_service_name(service_name: str = None) -> str:
     if service_name is None:
@@ -34,7 +45,7 @@ def get_service_name(service_name: str = None) -> str:
 
 def get_service_version(service_version: str = None) -> str:
     if service_version is None:
-        return os.environ.get('OTEL_SERVICE_VERSION', '1.0.0')
+        return os.environ.get('OTEL_SERVICE_VERSION', get_package_version())
     return service_version
 
 

rebrandly_otel/rebrandly_otel.py

@@ -1,7 +1,5 @@
-# rebrandly_otel.py
-"""
-Rebrandly OpenTelemetry SDK - Simplified instrumentation for Rebrandly services.
-"""
+
+import json
 import time
 import psutil
 import functools
@@ -99,8 +97,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 +128,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 +157,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 +169,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 +236,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 +306,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 +361,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 +372,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 +418,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 +493,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 +502,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 +514,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(
@@ -520,4 +547,4 @@ extract_context = otel.extract_context
 attach_context = otel.attach_context
 detach_context = otel.detach_context
 force_flush = otel.force_flush
-shutdown = otel.shutdown
+shutdown = otel.shutdown

{rebrandly_otel-0.1.14.dist-info → rebrandly_otel-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.14
+Version: 0.1.17
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -119,6 +119,21 @@ meter.GlobalMetrics.invocations.add(1, {'function': 'my_function'})
 meter.GlobalMetrics.duration.record(150.5, {'source': 'api'})
 ```
 
+### Custom Metrics
+
+You can create the custom metrics you need using the default open telemetry metrics
+
+```python
+from src.rebrandly_otel import meter
+
+sqs_counter = meter.meter.create_counter(
+    name="sqs_sender_counter",
+    description="Number of messages sent",
+    unit="1"
+)
+sqs_counter.add(1)
+```
+
 ## Tracing Features
 
 ### Automatic Context Propagation
@@ -319,6 +334,47 @@ def process_message(record):
             logger.info(f"Message data: {body}")
 ```
 
+###
+Flask
+
+```python
+
+from flask import Flask, jsonify
+from src.rebrandly_otel import otel, logger, app_before_request, app_after_request, flask_error_handler
+from datetime import datetime
+
+app = Flask(__name__)
+
+# Register the centralized OTEL handlers
+app.before_request(app_before_request)
+app.after_request(app_after_request)
+app.register_error_handler(Exception, flask_error_handler)
+
+@app.route('/health')
+def health():
+    logger.info("Health check requested")
+    return jsonify({"status": "healthy"}), 200
+
+@app.route('/process', methods=['POST', 'GET'])
+def process():
+    with otel.span("process_request"):
+        logger.info("Processing POST request")
+
+        # Simulate processing
+        result = {"processed": True, "timestamp": datetime.now().isoformat()}
+
+        logger.info(f"Returning result: {result}")
+        return jsonify(result), 200
+
+@app.route('/error')
+def error():
+    logger.error("Error endpoint called")
+    raise Exception("Simulated error")
+
+if __name__ == '__main__':
+    app.run(debug=True)
+```
+
 ### More examples
 You can find More examples [here](examples)
 

rebrandly_otel-0.1.17.dist-info/RECORD

@@ -0,0 +1,12 @@
+rebrandly_otel/__init__.py,sha256=MtIlcsWV1m1NAkrraS9SviDXaHybveOAV1RQi5lm_kM,323
+rebrandly_otel/flask_support.py,sha256=BX3DPF9TYRNounfQEt0GV3oV6rMUJtHXrRRioF31TXA,6424
+rebrandly_otel/logs.py,sha256=92jaxzI5hCHnKHu3lsSAa7K_SPHQgL46AlQUESsYNds,3724
+rebrandly_otel/metrics.py,sha256=57jwrn8e1u66BOO7fcFrmtE3Rpt4VDixG9I78K-zrUU,8537
+rebrandly_otel/otel_utils.py,sha256=tKelaETEeZxxvddKDpY8ESsGS77CcBbQku4oQjmiJx0,2078
+rebrandly_otel/rebrandly_otel.py,sha256=DUhO_79jVq3rwm7HmKzw-hIx3snBW31PAxgWu14jIGo,23096
+rebrandly_otel/traces.py,sha256=v582WtJv3t4Bn92vlDyZouibHtgWNxdRo_XmQCmSOEA,7126
+rebrandly_otel-0.1.17.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
+rebrandly_otel-0.1.17.dist-info/METADATA,sha256=NieFA0UNJfoLZ2pnqbMJrQ9NY58OYrftgRG35bQE9AU,10971
+rebrandly_otel-0.1.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rebrandly_otel-0.1.17.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
+rebrandly_otel-0.1.17.dist-info/RECORD,,

rebrandly_otel-0.1.14.dist-info/RECORD

@@ -1,11 +0,0 @@
-rebrandly_otel/__init__.py,sha256=NUlroPhnHAKVC_q2BiyhtURXw23w1YY1BJd45gtc9qM,275
-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=KwUWW1kiWZrB9B2xwioBsA_c-Xm4YoH51_HyX6HBvQY,21778
-rebrandly_otel/traces.py,sha256=v582WtJv3t4Bn92vlDyZouibHtgWNxdRo_XmQCmSOEA,7126
-rebrandly_otel-0.1.14.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
-rebrandly_otel-0.1.14.dist-info/METADATA,sha256=tfOB74T9zcU5aXOj3Rw6bHChrd9-wexzkq7FqQUWptY,9628
-rebrandly_otel-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rebrandly_otel-0.1.14.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
-rebrandly_otel-0.1.14.dist-info/RECORD,,