rebrandly-otel 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

rebrandly_otel/__init__.py

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

rebrandly_otel/fastapi_support.py

@@ -0,0 +1,198 @@
+# fastapi_integration.py
+"""FastAPI integration for Rebrandly OTEL SDK."""
+import json
+from rebrandly_otel import Status, StatusCode, SpanKind
+from fastapi import HTTPException, Depends
+from starlette.requests import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from fastapi.responses import JSONResponse
+
+import time
+
+def setup_fastapi(otel , app):
+    """
+    Setup FastAPI application with OTEL instrumentation.
+
+    Example:
+        from fastapi import FastAPI
+        from rebrandly_otel import otel
+        from rebrandly_otel.fastapi_integration import setup_fastapi
+
+        app = FastAPI()
+        setup_fastapi(otel, app)
+    """
+
+    # Add middleware
+    add_otel_middleware(otel, app)
+
+    # Add exception handlers
+    app.add_exception_handler(HTTPException, lambda request, exc: fastapi_exception_handler(otel, request, exc))
+    app.add_exception_handler(Exception, lambda request, exc: fastapi_exception_handler(otel, request, exc))
+
+    return app
+
+def add_otel_middleware(otel, app):
+    """
+    Add OTEL middleware to FastAPI application.
+    """
+
+    class OTELMiddleware(BaseHTTPMiddleware):
+        def __init__(self, app):
+            super().__init__(app)
+            self.otel = otel
+
+        async def dispatch(self, request: Request, call_next):
+            # Extract trace context from headers
+            headers = dict(request.headers)
+            token = self.otel.attach_context(headers)
+
+            # Start span for request
+            span_name = f"{request.method} {request.url.path}"
+
+            # Use start_as_current_span for proper context propagation
+            with self.otel.tracer.tracer.start_as_current_span(
+                    span_name,
+                    attributes={
+                        # Required HTTP attributes per semantic conventions
+                        "http.request.method": request.method,
+                        "http.request.headers": json.dumps(request.headers, default=str),
+                        "http.response.status_code": None,  # Will be set after response
+                        "url.full": str(request.url),
+                        "url.scheme": request.url.scheme,
+                        "url.path": request.url.path,
+                        "url.query": request.url.query if request.url.query else None,
+                        "user_agent.original": request.headers.get("user-agent"),
+                        "http.route": None,  # Will be set after routing
+                        "network.protocol.version": "1.1",  # FastAPI/Starlette typically uses HTTP/1.1
+                        "server.address": request.url.hostname,
+                        "server.port": request.url.port or (443 if request.url.scheme == 'https' else 80),
+                        "client.address": request.client.host if request.client else None,
+                    },
+                    kind=SpanKind.SERVER
+            ) as span:
+                # Log request start
+                self.otel.logger.logger.info(f"Request started: {request.method} {request.url.path}",
+                                             extra={"http.method": request.method, "http.path": request.url.path})
+
+                # Store span in request state for access in routes
+                request.state.span = span
+                request.state.trace_token = token
+
+                start_time = time.time()
+
+                try:
+                    # Process request
+                    response = await call_next(request)
+
+                    # After routing, update span name and route if available
+                    if hasattr(request, 'scope') and 'path' in request.scope:
+                        route = request.scope.get('path', request.url.path)
+                        span.update_name(f"{request.method} {route}")
+                        span.set_attribute("http.route", route)
+
+                    # Set response attributes using new semantic conventions
+                    span.set_attribute("http.response.status_code", response.status_code)
+                    span.set_attribute("http.status_code", response.status_code)  # Deprecated
+
+                    # Set span status based on HTTP status code
+                    if response.status_code >= 400:
+                        span.set_status(Status(StatusCode.ERROR, f"HTTP {response.status_code}"))
+                    else:
+                        span.set_status(Status(StatusCode.OK))
+
+                    # Log request completion
+                    self.otel.logger.logger.info(f"Request completed: {response.status_code}",
+                                                 extra={"http.status_code": response.status_code})
+                    otel.force_flush(timeout_millis=100)
+                    return response
+
+                except Exception as e:
+                    # Record exception
+                    span.record_exception(e)
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    span.add_event("exception", {
+                        "exception.type": type(e).__name__,
+                        "exception.message": str(e)
+                    })
+
+                    # Log error
+                    self.otel.logger.logger.error(f"Unhandled exception: {e}",
+                                                  exc_info=True,
+                                                  extra={"exception.type": type(e).__name__})
+
+                    raise
+
+                finally:
+                    # Detach context
+                    self.otel.detach_context(token)
+
+    # Add middleware to app
+    app.add_middleware(OTELMiddleware)
+
+def fastapi_exception_handler(otel, request, exc):
+    """
+    Handle FastAPI exceptions and record them in the current span.
+    """
+
+    # Determine the status code
+    if isinstance(exc, HTTPException):
+        status_code = exc.status_code
+        error_detail = exc.detail
+    elif hasattr(exc, 'status_code'):
+        status_code = exc.status_code
+        error_detail = str(exc)
+    elif hasattr(exc, 'code'):
+        status_code = exc.code if isinstance(exc.code, int) else 500
+        error_detail = str(exc)
+    else:
+        status_code = 500
+        error_detail = str(exc)
+
+    # Record exception in span if available and still recording
+    if hasattr(request.state, 'span') and request.state.span.is_recording():
+        # Update both new and old attribute names for compatibility
+        request.state.span.set_attribute("http.response.status_code", status_code)
+        request.state.span.set_attribute("error.type", type(exc).__name__)
+
+        request.state.span.record_exception(exc)
+        request.state.span.set_status(Status(StatusCode.ERROR, str(exc)))
+        request.state.span.add_event("exception", {
+            "exception.type": type(exc).__name__,
+            "exception.message": str(exc)
+        })
+
+    # Log the error
+    otel.logger.logger.error(f"Unhandled exception: {exc} (status: {status_code})",
+                             exc_info=True,
+                             extra={
+                                 "exception.type": type(exc).__name__,
+                                 "http.status_code": status_code
+                             })
+
+    # Return error response
+    return JSONResponse(
+        status_code=status_code,
+        content={
+            "error": error_detail,
+            "type": type(exc).__name__
+        }
+    )
+
+# Optional: Dependency injection helper for accessing the span in routes
+def get_current_span(request: Request):
+    """
+    FastAPI dependency to get the current span in route handlers.
+
+    Example:
+        from fastapi import Depends
+        from rebrandly_otel.fastapi_integration import get_current_span
+
+        @app.get("/example")
+        async def example(span = Depends(get_current_span)):
+            if span:
+                span.add_event("custom_event", {"key": "value"})
+            return {"status": "ok"}
+    """
+    if hasattr(request.state, 'span'):
+        return request.state.span
+    return None

rebrandly_otel/flask_support.py

@@ -0,0 +1,153 @@
+# flask_integration.py
+"""Flask integration for Rebrandly OTEL SDK."""
+
+import json
+from rebrandly_otel import Status, StatusCode, SpanKind
+
+from flask import request, jsonify
+from werkzeug.exceptions import HTTPException
+
+
+def setup_flask(otel, 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):
+    """
+    Setup tracing for incoming Flask request.
+    To be used with Flask's before_request hook.
+    """
+
+    # Extract trace context from headers
+    headers = dict(request.headers)
+    token = otel.attach_context(headers)
+    request.trace_token = token
+
+    # Determine span name - use route if available, otherwise just method
+    # Route will be available after request routing is done
+    span_name = f"{request.method} {request.path}"
+
+    # Start span for request using start_as_current_span to make it the active span
+    span = otel.tracer.tracer.start_as_current_span(
+        span_name,
+        attributes={
+            # Required HTTP attributes per semantic conventions
+            "http.request.method": request.method,
+            "http.request.headers": json.dumps(request.headers, default=str),
+            "http.response.status_code": None,  # Will be set in after_request
+            "url.full": request.url,
+            "url.scheme": request.scheme,
+            "url.path": request.path,
+            "url.query": request.query_string.decode('utf-8') if request.query_string else None,
+            "user_agent.original": request.user_agent.string if request.user_agent else None,
+            "http.route": request.path,  # Flask doesn't expose route pattern easily
+            "network.protocol.version": request.environ.get('SERVER_PROTOCOL', 'HTTP/1.1').split('/')[-1],
+            "server.address": request.host.split(':')[0],
+            "server.port": request.host.split(':')[1] if ':' in request.host else (443 if request.scheme == 'https' else 80),
+            "client.address": request.remote_addr,
+        },
+        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, response):
+    """
+    Cleanup tracing after Flask request completes.
+    To be used with Flask's after_request hook.
+    """
+
+    # Check if we have a span and it's still recording
+    if hasattr(request, 'span') and request.span.is_recording():
+        # Update both new and old attribute names for compatibility
+        request.span.set_attribute("http.response.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}"))
+        else:
+            request.span.set_status(Status(StatusCode.OK))
+
+        # 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})
+
+    otel.force_flush(timeout_millis=100)
+    return response
+
+def flask_error_handler(otel, exception):
+    """
+    Handle Flask exceptions and record them in the current span.
+    To be used with Flask's errorhandler decorator.
+    """
+
+    # 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.response.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)
+        })
+
+        # 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
+                             })
+
+    # Return error response with the determined status code
+    return jsonify({
+        "error": str(exception),
+        "type": type(exception).__name__
+    }), status_code

rebrandly_otel/metrics.py

@@ -34,51 +34,24 @@ class RebrandlyMeter:
 
     # Standardized metric definitions aligned with Node.js
     DEFAULT_METRICS = {
-        'invocations': MetricDefinition(
-            name='invocations',
-            description='Number of invocations',
-            unit='1',
-            type=MetricType.COUNTER
-        ),
-        'successful_invocations': MetricDefinition(
-            name='successful_invocations',
-            description='Number of successful invocations',
-            unit='1',
-            type=MetricType.COUNTER
-        ),
-        'error_invocations': MetricDefinition(
-            name='error_invocations',
-            description='Number of error invocations',
-            unit='1',
-            type=MetricType.COUNTER
-        ),
-        'duration': MetricDefinition(
-            name='duration',
-            description='Duration of execution in milliseconds',
-            unit='ms',
-            type=MetricType.HISTOGRAM
-        ),
+        ## PROCESS
         'cpu_usage_percentage': MetricDefinition(
-            name='cpu_usage_percentage',
-            description='CPU usage percentage',
-            unit='%',
+            name='process.cpu.utilization',
+            description='Difference in process.cpu.time since the last measurement, divided by the elapsed time and number of CPUs available to the process.',
+            unit='1',
             type=MetricType.GAUGE
         ),
         'memory_usage_bytes': MetricDefinition(
-            name='memory_usage_bytes',
-            description='Memory usage in bytes',
+            name='process.memory.used',
+            description='The amount of physical memory in use.',
             unit='By',
             type=MetricType.GAUGE
-        ),
+        )
     }
 
     class GlobalMetrics:
         def __init__(self, rebrandly_meter):
             self.__rebrandly_meter = rebrandly_meter
-            self.invocations: Counter = self.__rebrandly_meter.get_metric('invocations')
-            self.successful_invocations: Counter = self.__rebrandly_meter.get_metric('successful_invocations')
-            self.error_invocations: Counter = self.__rebrandly_meter.get_metric('error_invocations')
-            self.duration: Histogram = self.__rebrandly_meter.get_metric('duration')
             self.cpu_usage_percentage: Gauge = self.__rebrandly_meter.get_metric('cpu_usage_percentage')
             self.memory_usage_bytes: Gauge = self.__rebrandly_meter.get_metric('memory_usage_bytes')
 

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,8 +1,5 @@
-# rebrandly_otel.py
-"""
-Rebrandly OpenTelemetry SDK - Simplified instrumentation for Rebrandly services.
-Updated for consistency with Node.js SDK
-"""
+
+import json
 import time
 import psutil
 import functools
@@ -163,8 +160,6 @@ class RebrandlyOTEL:
 
                 result = None
                 try:
-                    # Increment invocation counter with standardized metric name
-                    self.meter.GlobalMetrics.invocations.add(1, {'function': span_name})
 
                     # Create and execute within span
                     with self.tracer.start_span(
@@ -207,17 +202,9 @@ class RebrandlyOTEL:
                         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 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", {
@@ -239,13 +226,9 @@ class RebrandlyOTEL:
                         from opentelemetry import context as otel_context
                         otel_context.detach(token)
 
-                    # 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"[Rebrandly OTEL] Lambda '{span_name}' completed in {duration:.2f}ms, flushing...")
+                        self.logger.logger.info(f"[Rebrandly OTEL] Lambda '{span_name}', flushing...")
                         flush_success = self.force_flush(timeout_millis=1000)
                         if not flush_success:
                             self.logger.logger.warning("[Rebrandly OTEL] Force flush may not have completed fully")
@@ -275,9 +258,6 @@ class RebrandlyOTEL:
 
                 result = None
                 try:
-                    # 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 or 'messageAttributes' in record):
@@ -321,18 +301,9 @@ class RebrandlyOTEL:
                         complete_event_attrs['success'] = success
                         span_context.add_event("message.processing.complete", complete_event_attrs)
 
-                        # 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 with standardized metric
-                    self.meter.GlobalMetrics.error_invocations.add(1, {
-                        'handler': span_name,
-                        'error': type(e).__name__
-                    })
-
                     # Record the exception in the span
                     if 'span_context' in locals():
                         span_context.record_exception(e)
@@ -348,10 +319,6 @@ class RebrandlyOTEL:
                     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)
 
@@ -374,16 +341,14 @@ 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=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)
 
-            print(f"Function duration: {duration}ms, Memory usage: {memory.percent}%, CPU usage: {cpu_percent}%")
+            print(f"Function Memory usage: {memory.percent}%, CPU usage: {cpu_percent}%")
 
         try:
             # Flush traces
@@ -550,4 +515,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.16.dist-info → rebrandly_otel-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.16
+Version: 0.1.18
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -102,21 +102,23 @@ The SDK automatically registers and tracks the following metrics:
 
 ### Standard Metrics
 
-- **`invocations`** (Counter): Total number of function invocations
-- **`successful_invocations`** (Counter): Number of successful completions
-- **`error_invocations`** (Counter): Number of failed invocations
-- **`duration`** (Histogram): Execution duration in milliseconds
 - **`cpu_usage_percentage`** (Gauge): CPU utilization percentage
 - **`memory_usage_bytes`** (Gauge): Memory usage in bytes
 
-### Global Metrics Access
 
-```python
-from rebrandly_otel import meter
+### Custom Metrics
+
+You can create the custom metrics you need using the default open telemetry metrics
 
-# Access pre-configured metrics
-meter.GlobalMetrics.invocations.add(1, {'function': 'my_function'})
-meter.GlobalMetrics.duration.record(150.5, {'source': 'api'})
+```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
@@ -180,10 +182,8 @@ Automatically detects and labels Lambda triggers:
 ### Automatic Metrics
 
 For Lambda functions, the SDK automatically captures:
-- Function duration
 - Memory usage
 - CPU utilization
-- Invocation counts by status
 
 ### Context Extraction
 
@@ -319,6 +319,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.18.dist-info/RECORD

@@ -0,0 +1,13 @@
+rebrandly_otel/__init__.py,sha256=tkZQJo5hR4FJ4dIRc-3b_YGxGo-uq-DsiSz8shdac-k,397
+rebrandly_otel/fastapi_support.py,sha256=RuBBZJuzr3osBDrkHZ0oQPV70pmvnqxTfBBDVFBFQlo,8019
+rebrandly_otel/flask_support.py,sha256=cUVMGTjN6N8xZD4Zyng2LRWhNj62C5nmTH91SnYBp2A,6072
+rebrandly_otel/logs.py,sha256=92jaxzI5hCHnKHu3lsSAa7K_SPHQgL46AlQUESsYNds,3724
+rebrandly_otel/metrics.py,sha256=8Mgz_VcgsGQaBeYH2y6FtLGSqMqTwa2ilAa1pbYYymU,7472
+rebrandly_otel/otel_utils.py,sha256=tKelaETEeZxxvddKDpY8ESsGS77CcBbQku4oQjmiJx0,2078
+rebrandly_otel/rebrandly_otel.py,sha256=Es6ZQC2hr6qJ_M4Y-7nUvcAnGADj6-ofKn8hKFw7P1k,21166
+rebrandly_otel/traces.py,sha256=v582WtJv3t4Bn92vlDyZouibHtgWNxdRo_XmQCmSOEA,7126
+rebrandly_otel-0.1.18.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
+rebrandly_otel-0.1.18.dist-info/METADATA,sha256=CyoVBpLByY8eqh5C7UTmKTBH62thbZww1GxPjYKSV6Y,10410
+rebrandly_otel-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rebrandly_otel-0.1.18.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
+rebrandly_otel-0.1.18.dist-info/RECORD,,

rebrandly_otel-0.1.16.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=A_TGyCQq752EeEvcsMmBWaWx2Z12J1hfmyYTFpYJFbo,23232
-rebrandly_otel/traces.py,sha256=v582WtJv3t4Bn92vlDyZouibHtgWNxdRo_XmQCmSOEA,7126
-rebrandly_otel-0.1.16.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
-rebrandly_otel-0.1.16.dist-info/METADATA,sha256=4SxmMqhoIM6EyjZc8_JWCvHHxATQvuXcKztv5gEqc18,9628
-rebrandly_otel-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rebrandly_otel-0.1.16.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
-rebrandly_otel-0.1.16.dist-info/RECORD,,