rebrandly-otel 0.1.20__py3-none-any.whl → 0.1.23__py3-none-any.whl

rebrandly_otel/__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/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/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/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]'

{rebrandly_otel-0.1.20.dist-info → rebrandly_otel-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.1.20
+Version: 0.1.23
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -10,6 +10,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: opentelemetry-api>=1.34.0
+Requires-Dist: opentelemetry-sdk>=1.34.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.34.0
+Requires-Dist: psutil>=5.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -17,6 +21,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license-file
+Dynamic: requires-dist
 Dynamic: summary
 
 # Rebrandly OpenTelemetry SDK for Python
@@ -447,6 +452,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.23.dist-info/RECORD

@@ -0,0 +1,14 @@
+rebrandly_otel/__init__.py,sha256=dEcTvHbhNNp0XD_7jojxeHXNa1QDCI9HxayeICaK_WY,491
+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=Tf21BwSVK6eLPG2hz55gNpwdPq85uqAx4bttLO6rnq8,7542
+rebrandly_otel/otel_utils.py,sha256=bP6Xhel4g7gbQWzCUlABWJfBSJaveKU1fhSOngcfzc4,3577
+rebrandly_otel/pymysql_instrumentation.py,sha256=4MNIfqNQlMtOcmYLy5bq8FP0KoEw72bcZZqBdG6xupM,5955
+rebrandly_otel/rebrandly_otel.py,sha256=wT1GiOQQMZl2sVG8MGJ9qM9gx_zRwS7U5oAe77RbJdk,21618
+rebrandly_otel/traces.py,sha256=JY_3RWbzpUxzEx3GqTVgggsyA2DB4oR-zDftIFFJha4,7174
+rebrandly_otel-0.1.23.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
+rebrandly_otel-0.1.23.dist-info/METADATA,sha256=0aW8pxbWwRsR3-QN1kYCsiiC4BsYwJ-uf_iO--tC9mc,14478
+rebrandly_otel-0.1.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rebrandly_otel-0.1.23.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
+rebrandly_otel-0.1.23.dist-info/RECORD,,

rebrandly_otel-0.1.20.dist-info/RECORD

@@ -1,13 +0,0 @@
-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=DodoBBqzDlo3pC5TLmWT2eAAE8NvW6MxxAoBrfVaxc4,3572
-rebrandly_otel/rebrandly_otel.py,sha256=wT1GiOQQMZl2sVG8MGJ9qM9gx_zRwS7U5oAe77RbJdk,21618
-rebrandly_otel/traces.py,sha256=JY_3RWbzpUxzEx3GqTVgggsyA2DB4oR-zDftIFFJha4,7174
-rebrandly_otel-0.1.20.dist-info/licenses/LICENSE,sha256=KMXHvTwP62S2q-SG7CFfMU_09rUwxiqlM0izaYGdcgY,1103
-rebrandly_otel-0.1.20.dist-info/METADATA,sha256=II9R2GM1UWTYg-JmUbQewcXR9J_jww3eiKVOApklmkM,12854
-rebrandly_otel-0.1.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rebrandly_otel-0.1.20.dist-info/top_level.txt,sha256=26PSC1gjVUl8tTH5QfKbFevjVV4E2yojoukEfiTScvM,15
-rebrandly_otel-0.1.20.dist-info/RECORD,,