rebrandly-otel 0.1.17__tar.gz → 0.1.19__tar.gz

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.19}/PKG-INFO

@@ -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.17 → rebrandly_otel-0.1.19}/README.md

@@ -81,22 +81,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
 
@@ -174,10 +161,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
 
@@ -354,6 +339,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.17 → rebrandly_otel-0.1.19}/rebrandly_otel.egg-info/PKG-INFO

@@ -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.17 → rebrandly_otel-0.1.19}/rebrandly_otel.egg-info/SOURCES.txt

@@ -6,9 +6,11 @@ rebrandly_otel.egg-info/SOURCES.txt
 rebrandly_otel.egg-info/dependency_links.txt
 rebrandly_otel.egg-info/top_level.txt
 src/__init__.py
+src/fastapi_support.py
 src/flask_support.py
 src/logs.py
 src/metrics.py
 src/otel_utils.py
 src/rebrandly_otel.py
-src/traces.py
+src/traces.py
+tests/test_usage.py

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.19}/setup.py

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

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.19}/src/__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-0.1.19/src/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