rebrandly-otel 0.1.20__tar.gz → 0.1.22__tar.gz

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.20
+Version: 0.1.22
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -447,6 +447,52 @@ if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=8000)
 ```
 
+### PyMySQL Database Instrumentation
+
+The SDK provides connection-level instrumentation for PyMySQL that automatically traces all queries without requiring you to instrument each query individually.
+
+```python
+import pymysql
+from rebrandly_otel import otel, logger, instrument_pymysql
+
+# Initialize OTEL
+otel.initialize()
+
+# Create and instrument your connection
+connection = pymysql.connect(
+    host='localhost',
+    user='your_user',
+    password='your_password',
+    database='your_database'
+)
+
+# Instrument the connection - all queries are now automatically traced
+connection = instrument_pymysql(otel, connection, options={
+    'slow_query_threshold_ms': 1000,  # Queries over 1s flagged as slow
+    'capture_bindings': False  # Set True to capture query parameters
+})
+
+# Use normally - all queries automatically traced
+with connection.cursor() as cursor:
+    cursor.execute("SELECT * FROM users WHERE id = %s", (123,))
+    result = cursor.fetchone()
+    logger.info(f"Found user: {result}")
+
+connection.close()
+otel.force_flush()
+```
+
+Features:
+- Automatic span creation for all queries
+- Query operation detection (SELECT, INSERT, UPDATE, etc.)
+- Slow query detection and flagging
+- Duration tracking
+- Error recording with exception details
+- Optional query parameter capture (disabled by default for security)
+
+Environment configuration:
+- `PYMYSQL_SLOW_QUERY_THRESHOLD_MS`: Threshold for slow query detection (default: 1500ms)
+
 ### More examples
 You can find More examples [here](examples)
 

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/README.md

@@ -426,6 +426,52 @@ if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=8000)
 ```
 
+### PyMySQL Database Instrumentation
+
+The SDK provides connection-level instrumentation for PyMySQL that automatically traces all queries without requiring you to instrument each query individually.
+
+```python
+import pymysql
+from rebrandly_otel import otel, logger, instrument_pymysql
+
+# Initialize OTEL
+otel.initialize()
+
+# Create and instrument your connection
+connection = pymysql.connect(
+    host='localhost',
+    user='your_user',
+    password='your_password',
+    database='your_database'
+)
+
+# Instrument the connection - all queries are now automatically traced
+connection = instrument_pymysql(otel, connection, options={
+    'slow_query_threshold_ms': 1000,  # Queries over 1s flagged as slow
+    'capture_bindings': False  # Set True to capture query parameters
+})
+
+# Use normally - all queries automatically traced
+with connection.cursor() as cursor:
+    cursor.execute("SELECT * FROM users WHERE id = %s", (123,))
+    result = cursor.fetchone()
+    logger.info(f"Found user: {result}")
+
+connection.close()
+otel.force_flush()
+```
+
+Features:
+- Automatic span creation for all queries
+- Query operation detection (SELECT, INSERT, UPDATE, etc.)
+- Slow query detection and flagging
+- Duration tracking
+- Error recording with exception details
+- Optional query parameter capture (disabled by default for security)
+
+Environment configuration:
+- `PYMYSQL_SLOW_QUERY_THRESHOLD_MS`: Threshold for slow query detection (default: 1500ms)
+
 ### More examples
 You can find More examples [here](examples)
 

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/rebrandly_otel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.20
+Version: 0.1.22
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -447,6 +447,52 @@ if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=8000)
 ```
 
+### PyMySQL Database Instrumentation
+
+The SDK provides connection-level instrumentation for PyMySQL that automatically traces all queries without requiring you to instrument each query individually.
+
+```python
+import pymysql
+from rebrandly_otel import otel, logger, instrument_pymysql
+
+# Initialize OTEL
+otel.initialize()
+
+# Create and instrument your connection
+connection = pymysql.connect(
+    host='localhost',
+    user='your_user',
+    password='your_password',
+    database='your_database'
+)
+
+# Instrument the connection - all queries are now automatically traced
+connection = instrument_pymysql(otel, connection, options={
+    'slow_query_threshold_ms': 1000,  # Queries over 1s flagged as slow
+    'capture_bindings': False  # Set True to capture query parameters
+})
+
+# Use normally - all queries automatically traced
+with connection.cursor() as cursor:
+    cursor.execute("SELECT * FROM users WHERE id = %s", (123,))
+    result = cursor.fetchone()
+    logger.info(f"Found user: {result}")
+
+connection.close()
+otel.force_flush()
+```
+
+Features:
+- Automatic span creation for all queries
+- Query operation detection (SELECT, INSERT, UPDATE, etc.)
+- Slow query detection and flagging
+- Duration tracking
+- Error recording with exception details
+- Optional query parameter capture (disabled by default for security)
+
+Environment configuration:
+- `PYMYSQL_SLOW_QUERY_THRESHOLD_MS`: Threshold for slow query detection (default: 1500ms)
+
 ### More examples
 You can find More examples [here](examples)
 

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/rebrandly_otel.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/flask_support.py
 src/logs.py
 src/metrics.py
 src/otel_utils.py
+src/pymysql_instrumentation.py
 src/rebrandly_otel.py
 src/traces.py
 tests/test_usage.py

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/setup.py

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

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/src/__init__.py

@@ -2,9 +2,11 @@
 from .rebrandly_otel import *
 from .flask_support import setup_flask
 from .fastapi_support import setup_fastapi
+from .pymysql_instrumentation import instrument_pymysql
 
 # Explicitly define what's available
 __all__ = [
+    'otel',
     'lambda_handler',
     'span',
     'aws_message_span',
@@ -16,5 +18,6 @@ __all__ = [
     'aws_message_handler',
     'shutdown',
     'setup_flask',
-    'setup_fastapi'
+    'setup_fastapi',
+    'instrument_pymysql'
 ]

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/src/metrics.py

@@ -111,7 +111,7 @@ class RebrandlyMeter:
         histogram_view = View(
             instrument_type=Histogram,
             instrument_name="*",
-            aggregation=ExplicitBucketHistogramAggregation((0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10)) # todo <-- define buckets
+            aggregation=ExplicitBucketHistogramAggregation((0.001, 0.004, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5)) # todo <-- define buckets
         )
         views.append(histogram_view)
 

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.22}/src/otel_utils.py

@@ -22,7 +22,7 @@ def create_resource(name: str = None, version: str = None) -> Resource:
             service_attributes.SERVICE_NAME: name,
             service_attributes.SERVICE_VERSION: version,
             process_attributes.PROCESS_RUNTIME_VERSION: f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-            deployment_attributes.DEPLOYMENT_ENVIRONMENT: os.environ.get('ENV', os.environ.get('ENVIRONMENT', os.environ.get('NODE_ENV', 'local')))
+            deployment_attributes.DEPLOYMENT_ENVIRONMENT_NAME: os.environ.get('ENV', os.environ.get('ENVIRONMENT', os.environ.get('NODE_ENV', 'local')))
         }
     )
     return resource

rebrandly_otel-0.1.22/src/pymysql_instrumentation.py

@@ -0,0 +1,206 @@
+"""
+PyMySQL instrumentation for Rebrandly OTEL SDK
+Provides query tracing and slow query detection
+"""
+
+import os
+import time
+import functools
+from opentelemetry.trace import Status, StatusCode, SpanKind
+
+# Environment configuration
+SLOW_QUERY_THRESHOLD_MS = int(os.getenv('PYMYSQL_SLOW_QUERY_THRESHOLD_MS', '1500'))
+MAX_QUERY_LENGTH = 2000  # Truncate long queries
+
+
+def instrument_pymysql(otel_instance, connection, options=None):
+    """
+    Instrument a PyMySQL connection for OpenTelemetry tracing
+
+    Args:
+        otel_instance: The RebrandlyOTEL instance
+        connection: The PyMySQL connection to instrument
+        options: Configuration options dict with:
+            - slow_query_threshold_ms: Threshold for slow query detection (default: 1500ms)
+            - capture_bindings: Include query bindings in spans (default: False for security)
+
+    Returns:
+        The instrumented connection
+    """
+    if options is None:
+        options = {}
+
+    slow_query_threshold_ms = options.get('slow_query_threshold_ms', SLOW_QUERY_THRESHOLD_MS)
+    capture_bindings = options.get('capture_bindings', False)
+
+    if not connection:
+        print('[Rebrandly OTEL PyMySQL] No connection provided for instrumentation')
+        return connection
+
+    if not otel_instance or not hasattr(otel_instance, 'tracer'):
+        print('[Rebrandly OTEL PyMySQL] No valid OTEL instance provided for instrumentation')
+        return connection
+
+    # Get tracer from RebrandlyOTEL instance
+    tracer = otel_instance.tracer
+
+    # Wrap the cursor method to return instrumented cursors
+    original_cursor = connection.cursor
+
+    def instrumented_cursor(*args, **kwargs):
+        cursor = original_cursor(*args, **kwargs)
+        return _instrument_cursor(cursor, tracer, slow_query_threshold_ms, capture_bindings)
+
+    connection.cursor = instrumented_cursor
+
+    return connection
+
+
+def _instrument_cursor(cursor, tracer, slow_query_threshold_ms, capture_bindings):
+    """
+    Instrument a cursor's execute methods
+    """
+    original_execute = cursor.execute
+    original_executemany = cursor.executemany
+
+    @functools.wraps(original_execute)
+    def instrumented_execute(query, args=None):
+        return _trace_query(
+            original_execute,
+            tracer,
+            slow_query_threshold_ms,
+            capture_bindings,
+            query,
+            args,
+            many=False
+        )
+
+    @functools.wraps(original_executemany)
+    def instrumented_executemany(query, args):
+        return _trace_query(
+            original_executemany,
+            tracer,
+            slow_query_threshold_ms,
+            capture_bindings,
+            query,
+            args,
+            many=True
+        )
+
+    cursor.execute = instrumented_execute
+    cursor.executemany = instrumented_executemany
+
+    return cursor
+
+
+def _trace_query(func, tracer, slow_query_threshold_ms, capture_bindings, query, args, many=False):
+    """
+    Trace a query execution with OpenTelemetry
+    """
+    operation = _extract_operation(query)
+    truncated_query = _truncate_query(query)
+
+    # Start span
+    span_name = f"pymysql.{'executemany' if many else 'execute'}"
+
+    with tracer.start_span(
+        name=span_name,
+        kind=SpanKind.CLIENT
+    ) as span:
+        # Set database attributes
+        span.set_attribute('db.system', 'mysql')
+        span.set_attribute('db.operation.name', operation)
+        span.set_attribute('db.statement', truncated_query)
+
+        # Add bindings if enabled (be cautious with sensitive data)
+        if capture_bindings and args:
+            if many:
+                span.set_attribute('db.bindings_count', len(args))
+            else:
+                span.set_attribute('db.bindings', str(args))
+
+        start_time = time.time()
+
+        try:
+            # Execute the query
+            result = func(query, args)
+
+            # Calculate duration
+            duration_ms = (time.time() - start_time) * 1000
+            span.set_attribute('db.duration_ms', duration_ms)
+
+            # Check for slow query
+            if duration_ms >= slow_query_threshold_ms:
+                span.set_attribute('db.slow_query', True)
+                span.add_event('slow_query_detected', {
+                    'db.duration_ms': duration_ms,
+                    'db.threshold_ms': slow_query_threshold_ms
+                })
+
+            # Set success status
+            span.set_status(Status(StatusCode.OK))
+
+            return result
+
+        except Exception as error:
+            # Calculate duration even on error
+            duration_ms = (time.time() - start_time) * 1000
+            span.set_attribute('db.duration_ms', duration_ms)
+
+            # Record exception
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
+
+            raise
+
+
+def _extract_operation(sql):
+    """
+    Extract operation type from SQL statement
+
+    Args:
+        sql: SQL query string
+
+    Returns:
+        Operation type (SELECT, INSERT, UPDATE, etc.)
+    """
+    if not sql:
+        return 'unknown'
+
+    normalized = sql.strip().upper()
+
+    if normalized.startswith('SELECT'):
+        return 'SELECT'
+    if normalized.startswith('INSERT'):
+        return 'INSERT'
+    if normalized.startswith('UPDATE'):
+        return 'UPDATE'
+    if normalized.startswith('DELETE'):
+        return 'DELETE'
+    if normalized.startswith('CREATE'):
+        return 'CREATE'
+    if normalized.startswith('DROP'):
+        return 'DROP'
+    if normalized.startswith('ALTER'):
+        return 'ALTER'
+    if normalized.startswith('TRUNCATE'):
+        return 'TRUNCATE'
+
+    return 'unknown'
+
+
+def _truncate_query(sql):
+    """
+    Truncate long queries for span attributes
+
+    Args:
+        sql: SQL query string
+
+    Returns:
+        Truncated query
+    """
+    if not sql:
+        return ''
+    if len(sql) <= MAX_QUERY_LENGTH:
+        return sql
+    return sql[:MAX_QUERY_LENGTH] + '... [truncated]'