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

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

@@ -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.20/PKG-INFO → rebrandly_otel-0.1.23/README.md

@@ -1,24 +1,3 @@
-Metadata-Version: 2.4
-Name: rebrandly_otel
-Version: 0.1.20
-Summary: Python OTEL wrapper by Rebrandly
-Home-page: https://github.com/rebrandly/rebrandly-otel-python
-Author: Antonio Romano
-Author-email: antonio@rebrandly.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: summary
-
 # Rebrandly OpenTelemetry SDK for Python
 
 A comprehensive OpenTelemetry instrumentation SDK designed specifically for Rebrandly services, with built-in support for AWS Lambda functions and message processing.
@@ -447,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)
 
@@ -471,4 +496,4 @@ If `build` gives you an error, try:
 
 > pyproject-build
 >
-> twine upload dist/*
+> twine upload dist/*

rebrandly_otel-0.1.20/README.md → rebrandly_otel-0.1.23/rebrandly_otel.egg-info/PKG-INFO

@@ -1,3 +1,29 @@
+Metadata-Version: 2.4
+Name: rebrandly_otel
+Version: 0.1.23
+Summary: Python OTEL wrapper by Rebrandly
+Home-page: https://github.com/rebrandly/rebrandly-otel-python
+Author: Antonio Romano
+Author-email: antonio@rebrandly.com
+Classifier: Programming Language :: Python :: 3
+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
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
 # Rebrandly OpenTelemetry SDK for Python
 
 A comprehensive OpenTelemetry instrumentation SDK designed specifically for Rebrandly services, with built-in support for AWS Lambda functions and message processing.
@@ -426,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)
 
@@ -450,4 +522,4 @@ If `build` gives you an error, try:
 
 > pyproject-build
 >
-> twine upload dist/*
+> twine upload dist/*

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

@@ -4,6 +4,7 @@ setup.py
 rebrandly_otel.egg-info/PKG-INFO
 rebrandly_otel.egg-info/SOURCES.txt
 rebrandly_otel.egg-info/dependency_links.txt
+rebrandly_otel.egg-info/requires.txt
 rebrandly_otel.egg-info/top_level.txt
 src/__init__.py
 src/fastapi_support.py
@@ -11,6 +12,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.23/rebrandly_otel.egg-info/requires.txt

@@ -0,0 +1,4 @@
+opentelemetry-api>=1.34.0
+opentelemetry-sdk>=1.34.0
+opentelemetry-exporter-otlp>=1.34.0
+psutil>=5.0.0

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.23}/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.23",
     author="Antonio Romano",
     author_email="antonio@rebrandly.com",
     description="Python OTEL wrapper by Rebrandly",
@@ -14,6 +14,12 @@ setuptools.setup(
     url="https://github.com/rebrandly/rebrandly-otel-python",
     packages=["rebrandly_otel"],
     package_dir={"rebrandly_otel": "src"},
+    install_requires=[
+        "opentelemetry-api>=1.34.0",
+        "opentelemetry-sdk>=1.34.0",
+        "opentelemetry-exporter-otlp>=1.34.0",
+        "psutil>=5.0.0",
+    ],
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",

{rebrandly_otel-0.1.20 → rebrandly_otel-0.1.23}/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.23}/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.23}/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.23/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]'