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

rebrandly_otel/__init__.py

@@ -1,6 +1,7 @@
 # src/__init__.py
 from .rebrandly_otel import *
-from .flask_support import *
+from .flask_support import setup_flask
+from .fastapi_support import setup_fastapi
 
 # Explicitly define what's available
 __all__ = [
@@ -14,5 +15,6 @@ __all__ = [
     'force_flush',
     'aws_message_handler',
     'shutdown',
-    'setup_flask'
+    '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

@@ -1,15 +1,17 @@
 # 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
+import json
+from rebrandly_otel import Status, StatusCode, SpanKind
 
-def setup_flask(otel: 'RebrandlyOTEL', app):
+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
@@ -23,31 +25,39 @@ def setup_flask(otel: 'RebrandlyOTEL', app):
     app.register_error_handler(Exception, lambda e: flask_error_handler(otel, e))
     return app
 
-def app_before_request(otel: 'RebrandlyOTEL'):
+def app_before_request(otel):
     """
     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
 
+    # 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(
-        f"{request.method} {request.path}",
+        span_name,
         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"
+            # 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
     )
@@ -59,33 +69,22 @@ def app_before_request(otel: 'RebrandlyOTEL'):
     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):
+def app_after_request(otel, 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)
+        # 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}"))
-            # 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'):
@@ -102,21 +101,14 @@ def app_after_request(otel: 'RebrandlyOTEL', response):
     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
-    })
-
+    otel.force_flush(timeout_millis=100)
     return response
 
-def flask_error_handler(otel: 'RebrandlyOTEL', exception):
+def flask_error_handler(otel, 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):
@@ -130,15 +122,14 @@ def flask_error_handler(otel: 'RebrandlyOTEL', exception):
 
     # 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("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),
-            "http.status_code": status_code
+            "exception.message": str(exception)
         })
 
         # Only close the span if it's still recording (not already ended)
@@ -155,14 +146,6 @@ def flask_error_handler(otel: 'RebrandlyOTEL', exception):
                                  "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),

rebrandly_otel/logs.py

@@ -1,6 +1,7 @@
 # logs.py
 """Logging implementation for Rebrandly OTEL SDK."""
 import logging
+import sys
 from typing import Optional
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import (
@@ -34,12 +35,15 @@ class RebrandlyLogger:
             self._provider.add_log_record_processor(SimpleLogRecordProcessor(console_exporter))
 
         # Add OTLP exporter if configured
-        if get_otlp_endpoint():
-            otlp_exporter = OTLPLogExporter(endpoint=get_otlp_endpoint())
+        otel_endpoint = get_otlp_endpoint()
+        if otel_endpoint:
+            otlp_exporter = OTLPLogExporter(
+                timeout=5,
+                endpoint=otel_endpoint
+            )
             batch_processor = BatchLogRecordProcessor(otlp_exporter, export_timeout_millis=get_millis_batch_time())
             self._provider.add_log_record_processor(batch_processor)
 
-        # Set as global provider
         set_logger_provider(self._provider)
 
         # Configure standard logging

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')
 
@@ -105,8 +78,12 @@ class RebrandlyMeter:
             readers.append(console_reader)
 
         # Add OTLP exporter if configured
-        if get_otlp_endpoint() is not None:
-            otlp_exporter = OTLPMetricExporter(endpoint=get_otlp_endpoint())
+        otel_endpoint = get_otlp_endpoint()
+        if otel_endpoint is not None:
+            otlp_exporter = OTLPMetricExporter(
+                endpoint=otel_endpoint,
+                timeout=5
+            )
             otlp_reader = PeriodicExportingMetricReader(otlp_exporter, export_interval_millis=get_millis_batch_time())
             readers.append(otlp_reader)
 

rebrandly_otel/otel_utils.py

@@ -3,6 +3,7 @@
 
 import os
 import sys
+import grpc
 
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.semconv.attributes import service_attributes
@@ -33,8 +34,9 @@ def get_package_version():
         try:
             from importlib_metadata import version, PackageNotFoundError
             return version('rebrandly_otel')
-        except:
-            return '?.0.1'
+        except Exception as e:
+            print(f"[OTEL Utils] Warning: Could not get package version: {e}")
+            return '0.1.0'
 
 
 def get_service_name(service_name: str = None) -> str:
@@ -49,10 +51,31 @@ def get_service_version(service_version: str = None) -> str:
     return service_version
 
 
-def get_otlp_endpoint(otlp_endpoint: str = None) -> str:
-    if otlp_endpoint is None:
-        return os.environ.get('OTEL_EXPORTER_OTLP_ENDPOINT', None)
-    return otlp_endpoint
+def get_otlp_endpoint(otlp_endpoint: str = None) -> str | None:
+    endpoint = otlp_endpoint or os.environ.get('OTEL_EXPORTER_OTLP_ENDPOINT', None)
+
+    if endpoint is not None:
+        try:
+            from urllib.parse import urlparse
+
+            # Parse the endpoint
+            parsed = urlparse(endpoint if '://' in endpoint else f'http://{endpoint}')
+            host = parsed.hostname
+            port = parsed.port
+
+            # Test gRPC connection
+            channel = grpc.insecure_channel(f'{host}:{port}')
+            try:
+                # Wait for the channel to be ready
+                grpc.channel_ready_future(channel).result(timeout=3)
+                return endpoint
+            finally:
+                channel.close()
+
+        except Exception as e:
+            print(f"[OTEL] Failed to connect to OTLP endpoint {endpoint}: {e}")
+            return None
+    return endpoint
 
 def is_otel_debug() -> bool:
     return os.environ.get('OTEL_DEBUG', 'false').lower() == 'true'
@@ -61,5 +84,6 @@ def is_otel_debug() -> bool:
 def get_millis_batch_time():
     try:
         return int(os.environ.get('BATCH_EXPORT_TIME_MILLIS', 100))
-    except:
+    except Exception as e:
+        print(f"[OTEL Utils] Warning: Invalid BATCH_EXPORT_TIME_MILLIS value, using default 5000ms: {e}")
         return 5000

rebrandly_otel/rebrandly_otel.py

@@ -160,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(
@@ -204,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", {
@@ -236,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")
@@ -272,12 +258,9 @@ 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):
+                    if record is not None and (('MessageAttributes' in record or 'messageAttributes' in record) or ('Sns' in record and 'MessageAttributes' in record['Sns'])):
                         span_function = self.aws_message_span
 
                     with span_function(span_name, message=record, attributes=span_attributes, kind=kind) as span_context:
@@ -318,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)
@@ -345,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)
 
@@ -371,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
@@ -402,6 +370,7 @@ class RebrandlyOTEL:
             time.sleep(0.1)
 
         except Exception as e:
+            print(f"[Rebrandly OTEL] Error during force flush: {e}")
             success = False
 
         return success

rebrandly_otel/traces.py

@@ -32,8 +32,12 @@ class RebrandlyTracer:
             self._provider.add_span_processor(SimpleSpanProcessor(console_exporter))
 
         # Add OTLP exporter if configured
-        if get_otlp_endpoint() is not None:
-            otlp_exporter = OTLPSpanExporter(endpoint=get_otlp_endpoint())
+        otel_endpoint = get_otlp_endpoint()
+        if otel_endpoint is not None:
+            otlp_exporter = OTLPSpanExporter(
+                endpoint=otel_endpoint,
+                timeout=5
+            )
 
             # Use batch processor for production
             batch_processor = BatchSpanProcessor(otlp_exporter, export_timeout_millis=get_millis_batch_time())
@@ -139,14 +143,14 @@ class RebrandlyTracer:
         if target_span and hasattr(target_span, 'record_exception'):
             if exception is not None:
                 target_span.record_exception(exception)
-            target_span.set_status(trace.Status(trace.StatusCode.ERROR, str(exception)), description=msg)
+                target_span.set_status(trace.Status(trace.StatusCode.ERROR, str(exception)))
 
 
     def record_span_success(self, span: Optional[Span] = None, msg: Optional[str] = None):
-        """Record an exception on a span."""
+        """Record success on a span."""
         target_span = span or self.get_current_span()
-        if target_span and hasattr(target_span, 'record_exception'):
-            target_span.set_status(trace.Status(trace.StatusCode.OK), description=msg)
+        if target_span and hasattr(target_span, 'set_status'):
+            target_span.set_status(trace.Status(trace.StatusCode.OK))
 
 
     def add_event(self, name: str, attributes: Optional[Dict[str, Any]] = None, span: Optional[Span] = None):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.17
+Version: 0.1.19
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -102,22 +102,9 @@ 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
-
-# Access pre-configured metrics
-meter.GlobalMetrics.invocations.add(1, {'function': 'my_function'})
-meter.GlobalMetrics.duration.record(150.5, {'source': 'api'})
-```
 
 ### Custom Metrics
 
@@ -195,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
 
@@ -375,6 +360,93 @@ if __name__ == '__main__':
     app.run(debug=True)
 ```
 
+###
+FastAPI
+
+```python
+
+# main_fastapi.py
+from fastapi import FastAPI, HTTPException, Depends
+from contextlib import asynccontextmanager
+from src.rebrandly_otel import otel, logger, force_flush
+from src.fastapi_support import setup_fastapi, get_current_span
+from datetime import datetime
+from typing import Optional
+import uvicorn
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    logger.info("FastAPI application starting up")
+    yield
+    # Shutdown
+    logger.info("FastAPI application shutting down")
+    force_flush()
+
+app = FastAPI(title="FastAPI OTEL Example", lifespan=lifespan)
+
+# Setup FastAPI with OTEL
+setup_fastapi(otel, app)
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    logger.info("Health check requested")
+    return {"status": "healthy"}
+
+@app.post("/process")
+@app.get("/process")
+async def process(span = Depends(get_current_span)):
+    """Process endpoint with custom span."""
+    with otel.span("process_request"):
+        logger.info("Processing request")
+
+        # You can also use the injected span directly
+        if span:
+            span.add_event("custom_processing_event", {
+                "timestamp": datetime.now().isoformat()
+            })
+
+        # Simulate some processing
+        result = {
+            "processed": True,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        logger.info(f"Returning result: {result}")
+        return result
+
+@app.get("/error")
+async def error():
+    """Endpoint that raises an error."""
+    logger.error("Error endpoint called")
+    raise HTTPException(status_code=400, detail="Simulated error")
+
+@app.get("/exception")
+async def exception():
+    """Endpoint that raises an unhandled exception."""
+    logger.error("Exception endpoint called")
+    raise ValueError("Simulated unhandled exception")
+
+@app.get("/items/{item_id}")
+async def get_item(item_id: int, q: Optional[str] = None):
+    """Example endpoint with path and query parameters."""
+    with otel.span("fetch_item", attributes={"item_id": item_id, "query": q}):
+        logger.info(f"Fetching item {item_id} with query: {q}")
+
+        if item_id == 999:
+            raise HTTPException(status_code=404, detail="Item not found")
+
+        return {
+            "item_id": item_id,
+            "name": f"Item {item_id}",
+            "query": q
+        }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
 ### More examples
 You can find More examples [here](examples)
 

rebrandly_otel-0.1.19.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=5byeN-cDmBRpeZDw9IBz_vuiJm3wsGEbcAk5pwYHNAU,3791
+rebrandly_otel/metrics.py,sha256=8aAqdr3SAcX_rVivTl_aHeD_BRByt-Qnfij_51Y7Fn0,7561
+rebrandly_otel/otel_utils.py,sha256=ej6ayM1e9muHx1RNaEBZJTBIL_G0QAtDkqkS1VsoTyo,3026
+rebrandly_otel/rebrandly_otel.py,sha256=hyNMFQzjZdP6oaXd0x1VKSKZg4-IuCtO6XeAiRZc7oo,21299
+rebrandly_otel/traces.py,sha256=JY_3RWbzpUxzEx3GqTVgggsyA2DB4oR-zDftIFFJha4,7174
+rebrandly_otel-0.1.19.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
+rebrandly_otel-0.1.19.dist-info/METADATA,sha256=DUACwLo6mJSEjir0pfY8kszp-G36JDnz5lh3uivRECg,12854
+rebrandly_otel-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rebrandly_otel-0.1.19.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
+rebrandly_otel-0.1.19.dist-info/RECORD,,

rebrandly_otel-0.1.17.dist-info/RECORD

@@ -1,12 +0,0 @@
-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,,