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

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

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

{rebrandly_otel-0.1.16 → rebrandly_otel-0.1.17}/README.md

@@ -98,6 +98,21 @@ meter.GlobalMetrics.invocations.add(1, {'function': 'my_function'})
 meter.GlobalMetrics.duration.record(150.5, {'source': 'api'})
 ```
 
+### Custom Metrics
+
+You can create the custom metrics you need using the default open telemetry metrics
+
+```python
+from src.rebrandly_otel import meter
+
+sqs_counter = meter.meter.create_counter(
+    name="sqs_sender_counter",
+    description="Number of messages sent",
+    unit="1"
+)
+sqs_counter.add(1)
+```
+
 ## Tracing Features
 
 ### Automatic Context Propagation
@@ -298,6 +313,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.16 → rebrandly_otel-0.1.17}/rebrandly_otel.egg-info/PKG-INFO

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

{rebrandly_otel-0.1.16 → rebrandly_otel-0.1.17}/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/flask_support.py
 src/logs.py
 src/metrics.py
 src/otel_utils.py

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

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

{rebrandly_otel-0.1.16 → rebrandly_otel-0.1.17}/src/__init__.py

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

rebrandly_otel-0.1.17/src/flask_support.py

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

{rebrandly_otel-0.1.16 → rebrandly_otel-0.1.17}/src/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-0.1.16 → rebrandly_otel-0.1.17}/src/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
@@ -550,4 +547,4 @@ extract_context = otel.extract_context
 attach_context = otel.attach_context
 detach_context = otel.detach_context
 force_flush = otel.force_flush
-shutdown = otel.shutdown
+shutdown = otel.shutdown