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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.17
+Version: 0.1.18
 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
 

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.18}/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
 

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.18}/rebrandly_otel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.17
+Version: 0.1.18
 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
 

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.18}/rebrandly_otel.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ 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

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.18}/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.18",
     author="Antonio Romano",
     author_email="antonio@rebrandly.com",
     description="Python OTEL wrapper by Rebrandly",

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.18}/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.18/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

{rebrandly_otel-0.1.17 → rebrandly_otel-0.1.18}/src/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-0.1.17 → rebrandly_otel-0.1.18}/src/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-0.1.17 → rebrandly_otel-0.1.18}/src/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,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):
@@ -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