rebrandly-otel 0.2.17__tar.gz → 0.2.19__tar.gz

{rebrandly_otel-0.2.17 → rebrandly_otel-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.2.17
+Version: 0.2.19
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -58,6 +58,7 @@ The SDK is configured through environment variables:
 | `OTEL_SERVICE_APPLICATION`         | Application namespace (groups multiple services under one application) | Fallback to `OTEL_SERVICE_NAME` |
 | `OTEL_EXPORTER_OTLP_ENDPOINT`      | OTLP collector endpoint | `None`                          |
 | `OTEL_DEBUG`                       | Enable console debugging | `false`                         |
+| `OTEL_SPAN_ATTRIBUTES`             | Attributes automatically added to all spans (format: `key1=value1,key2=value2`) | `None`                          |
 | `BATCH_EXPORT_TIME_MILLIS`         | Batch export interval | `100`                           |
 | `ENV` or `ENVIRONMENT` or `NODE_ENV`       | Deployment environment | `local`                         |
 
@@ -147,6 +148,67 @@ Lambda spans automatically include:
 - `cloud.provider`: Always "aws" for Lambda
 - `cloud.platform`: Always "aws_lambda" for Lambda
 
+## Automatic Span Attributes
+
+The SDK supports automatically adding custom attributes to all spans via the `OTEL_SPAN_ATTRIBUTES` environment variable. This is useful for adding metadata that applies to all telemetry in a service, such as team ownership, deployment environment, or version information.
+
+### Configuration
+
+Set the `OTEL_SPAN_ATTRIBUTES` environment variable with a comma-separated list of key-value pairs:
+
+```bash
+export OTEL_SPAN_ATTRIBUTES="team=backend,environment=production,version=1.2.3"
+```
+
+### Behavior
+
+- **Universal Application**: Attributes are added to ALL spans, including:
+  - Manually created spans (`tracer.start_span()`, `tracer.start_as_current_span()`)
+  - Lambda handler spans (`@lambda_handler`)
+  - AWS message handler spans (`@aws_message_handler`)
+  - Flask/FastAPI middleware spans
+  - Auto-instrumented spans (database queries, HTTP requests, etc.)
+
+- **Format**: Same as `OTEL_RESOURCE_ATTRIBUTES` - comma-separated `key=value` pairs
+- **Value Handling**: Supports values containing `=` characters (e.g., URLs)
+- **Whitespace**: Leading/trailing whitespace is automatically trimmed
+
+### Example
+
+```python
+import os
+
+# Set environment variable
+os.environ['OTEL_SPAN_ATTRIBUTES'] = "team=backend,service.owner=platform-team,deployment.region=us-east-1"
+
+# Initialize SDK
+from rebrandly_otel import otel, logger
+
+# Create any span - attributes are added automatically
+with otel.span('my-operation'):
+    logger.info('Processing request')
+    # The span will include:
+    # - team: "backend"
+    # - service.owner: "platform-team"
+    # - deployment.region: "us-east-1"
+    # ... plus any other attributes you set manually
+```
+
+### Use Cases
+
+- **Team/Ownership Tagging**: `team=backend,owner=john@example.com`
+- **Environment Metadata**: `environment=production,region=us-east-1,availability_zone=us-east-1a`
+- **Version Tracking**: `version=1.2.3,build=12345,commit=abc123def`
+- **Cost Attribution**: `cost_center=engineering,project=customer-api`
+- **Multi-Tenancy**: `tenant=acme-corp,customer_tier=enterprise`
+
+### Difference from OTEL_RESOURCE_ATTRIBUTES
+
+- **OTEL_RESOURCE_ATTRIBUTES**: Service-level metadata (set once, applies to the entire service instance)
+- **OTEL_SPAN_ATTRIBUTES**: Span-level metadata (added to each individual span at creation time)
+
+Both use the same format but serve different purposes in the OpenTelemetry data model.
+
 ### Exception Handling
 
 Spans automatically capture exceptions with:
@@ -522,6 +584,7 @@ pytest tests/test_usage.py -v
 pytest tests/test_pymysql_instrumentation.py -v
 pytest tests/test_metrics_and_logs.py -v
 pytest tests/test_decorators.py -v
+pytest tests/test_span_attributes_processor.py -v
 ```
 
 Run with coverage:
@@ -538,6 +601,7 @@ The test suite includes:
 - **PyMySQL instrumentation tests** (`test_pymysql_instrumentation.py`): Database connection instrumentation, query tracing, helper functions
 - **Metrics and logs tests** (`test_metrics_and_logs.py`): Custom metrics creation (counter, histogram, gauge), logging levels (info, warning, debug, error)
 - **Decorators tests** (`test_decorators.py`): Lambda handler decorator, AWS message handler decorator, traces decorator, aws_message_span context manager
+- **Span attributes processor tests** (`test_span_attributes_processor.py`): Automatic span attributes from OTEL_SPAN_ATTRIBUTES (31 tests)
 
 ## License
 

{rebrandly_otel-0.2.17 → rebrandly_otel-0.2.19}/README.md

@@ -31,6 +31,7 @@ The SDK is configured through environment variables:
 | `OTEL_SERVICE_APPLICATION`         | Application namespace (groups multiple services under one application) | Fallback to `OTEL_SERVICE_NAME` |
 | `OTEL_EXPORTER_OTLP_ENDPOINT`      | OTLP collector endpoint | `None`                          |
 | `OTEL_DEBUG`                       | Enable console debugging | `false`                         |
+| `OTEL_SPAN_ATTRIBUTES`             | Attributes automatically added to all spans (format: `key1=value1,key2=value2`) | `None`                          |
 | `BATCH_EXPORT_TIME_MILLIS`         | Batch export interval | `100`                           |
 | `ENV` or `ENVIRONMENT` or `NODE_ENV`       | Deployment environment | `local`                         |
 
@@ -120,6 +121,67 @@ Lambda spans automatically include:
 - `cloud.provider`: Always "aws" for Lambda
 - `cloud.platform`: Always "aws_lambda" for Lambda
 
+## Automatic Span Attributes
+
+The SDK supports automatically adding custom attributes to all spans via the `OTEL_SPAN_ATTRIBUTES` environment variable. This is useful for adding metadata that applies to all telemetry in a service, such as team ownership, deployment environment, or version information.
+
+### Configuration
+
+Set the `OTEL_SPAN_ATTRIBUTES` environment variable with a comma-separated list of key-value pairs:
+
+```bash
+export OTEL_SPAN_ATTRIBUTES="team=backend,environment=production,version=1.2.3"
+```
+
+### Behavior
+
+- **Universal Application**: Attributes are added to ALL spans, including:
+  - Manually created spans (`tracer.start_span()`, `tracer.start_as_current_span()`)
+  - Lambda handler spans (`@lambda_handler`)
+  - AWS message handler spans (`@aws_message_handler`)
+  - Flask/FastAPI middleware spans
+  - Auto-instrumented spans (database queries, HTTP requests, etc.)
+
+- **Format**: Same as `OTEL_RESOURCE_ATTRIBUTES` - comma-separated `key=value` pairs
+- **Value Handling**: Supports values containing `=` characters (e.g., URLs)
+- **Whitespace**: Leading/trailing whitespace is automatically trimmed
+
+### Example
+
+```python
+import os
+
+# Set environment variable
+os.environ['OTEL_SPAN_ATTRIBUTES'] = "team=backend,service.owner=platform-team,deployment.region=us-east-1"
+
+# Initialize SDK
+from rebrandly_otel import otel, logger
+
+# Create any span - attributes are added automatically
+with otel.span('my-operation'):
+    logger.info('Processing request')
+    # The span will include:
+    # - team: "backend"
+    # - service.owner: "platform-team"
+    # - deployment.region: "us-east-1"
+    # ... plus any other attributes you set manually
+```
+
+### Use Cases
+
+- **Team/Ownership Tagging**: `team=backend,owner=john@example.com`
+- **Environment Metadata**: `environment=production,region=us-east-1,availability_zone=us-east-1a`
+- **Version Tracking**: `version=1.2.3,build=12345,commit=abc123def`
+- **Cost Attribution**: `cost_center=engineering,project=customer-api`
+- **Multi-Tenancy**: `tenant=acme-corp,customer_tier=enterprise`
+
+### Difference from OTEL_RESOURCE_ATTRIBUTES
+
+- **OTEL_RESOURCE_ATTRIBUTES**: Service-level metadata (set once, applies to the entire service instance)
+- **OTEL_SPAN_ATTRIBUTES**: Span-level metadata (added to each individual span at creation time)
+
+Both use the same format but serve different purposes in the OpenTelemetry data model.
+
 ### Exception Handling
 
 Spans automatically capture exceptions with:
@@ -495,6 +557,7 @@ pytest tests/test_usage.py -v
 pytest tests/test_pymysql_instrumentation.py -v
 pytest tests/test_metrics_and_logs.py -v
 pytest tests/test_decorators.py -v
+pytest tests/test_span_attributes_processor.py -v
 ```
 
 Run with coverage:
@@ -511,6 +574,7 @@ The test suite includes:
 - **PyMySQL instrumentation tests** (`test_pymysql_instrumentation.py`): Database connection instrumentation, query tracing, helper functions
 - **Metrics and logs tests** (`test_metrics_and_logs.py`): Custom metrics creation (counter, histogram, gauge), logging levels (info, warning, debug, error)
 - **Decorators tests** (`test_decorators.py`): Lambda handler decorator, AWS message handler decorator, traces decorator, aws_message_span context manager
+- **Span attributes processor tests** (`test_span_attributes_processor.py`): Automatic span attributes from OTEL_SPAN_ATTRIBUTES (31 tests)
 
 ## License
 

{rebrandly_otel-0.2.17 → rebrandly_otel-0.2.19}/rebrandly_otel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebrandly_otel
-Version: 0.2.17
+Version: 0.2.19
 Summary: Python OTEL wrapper by Rebrandly
 Home-page: https://github.com/rebrandly/rebrandly-otel-python
 Author: Antonio Romano
@@ -58,6 +58,7 @@ The SDK is configured through environment variables:
 | `OTEL_SERVICE_APPLICATION`         | Application namespace (groups multiple services under one application) | Fallback to `OTEL_SERVICE_NAME` |
 | `OTEL_EXPORTER_OTLP_ENDPOINT`      | OTLP collector endpoint | `None`                          |
 | `OTEL_DEBUG`                       | Enable console debugging | `false`                         |
+| `OTEL_SPAN_ATTRIBUTES`             | Attributes automatically added to all spans (format: `key1=value1,key2=value2`) | `None`                          |
 | `BATCH_EXPORT_TIME_MILLIS`         | Batch export interval | `100`                           |
 | `ENV` or `ENVIRONMENT` or `NODE_ENV`       | Deployment environment | `local`                         |
 
@@ -147,6 +148,67 @@ Lambda spans automatically include:
 - `cloud.provider`: Always "aws" for Lambda
 - `cloud.platform`: Always "aws_lambda" for Lambda
 
+## Automatic Span Attributes
+
+The SDK supports automatically adding custom attributes to all spans via the `OTEL_SPAN_ATTRIBUTES` environment variable. This is useful for adding metadata that applies to all telemetry in a service, such as team ownership, deployment environment, or version information.
+
+### Configuration
+
+Set the `OTEL_SPAN_ATTRIBUTES` environment variable with a comma-separated list of key-value pairs:
+
+```bash
+export OTEL_SPAN_ATTRIBUTES="team=backend,environment=production,version=1.2.3"
+```
+
+### Behavior
+
+- **Universal Application**: Attributes are added to ALL spans, including:
+  - Manually created spans (`tracer.start_span()`, `tracer.start_as_current_span()`)
+  - Lambda handler spans (`@lambda_handler`)
+  - AWS message handler spans (`@aws_message_handler`)
+  - Flask/FastAPI middleware spans
+  - Auto-instrumented spans (database queries, HTTP requests, etc.)
+
+- **Format**: Same as `OTEL_RESOURCE_ATTRIBUTES` - comma-separated `key=value` pairs
+- **Value Handling**: Supports values containing `=` characters (e.g., URLs)
+- **Whitespace**: Leading/trailing whitespace is automatically trimmed
+
+### Example
+
+```python
+import os
+
+# Set environment variable
+os.environ['OTEL_SPAN_ATTRIBUTES'] = "team=backend,service.owner=platform-team,deployment.region=us-east-1"
+
+# Initialize SDK
+from rebrandly_otel import otel, logger
+
+# Create any span - attributes are added automatically
+with otel.span('my-operation'):
+    logger.info('Processing request')
+    # The span will include:
+    # - team: "backend"
+    # - service.owner: "platform-team"
+    # - deployment.region: "us-east-1"
+    # ... plus any other attributes you set manually
+```
+
+### Use Cases
+
+- **Team/Ownership Tagging**: `team=backend,owner=john@example.com`
+- **Environment Metadata**: `environment=production,region=us-east-1,availability_zone=us-east-1a`
+- **Version Tracking**: `version=1.2.3,build=12345,commit=abc123def`
+- **Cost Attribution**: `cost_center=engineering,project=customer-api`
+- **Multi-Tenancy**: `tenant=acme-corp,customer_tier=enterprise`
+
+### Difference from OTEL_RESOURCE_ATTRIBUTES
+
+- **OTEL_RESOURCE_ATTRIBUTES**: Service-level metadata (set once, applies to the entire service instance)
+- **OTEL_SPAN_ATTRIBUTES**: Span-level metadata (added to each individual span at creation time)
+
+Both use the same format but serve different purposes in the OpenTelemetry data model.
+
 ### Exception Handling
 
 Spans automatically capture exceptions with:
@@ -522,6 +584,7 @@ pytest tests/test_usage.py -v
 pytest tests/test_pymysql_instrumentation.py -v
 pytest tests/test_metrics_and_logs.py -v
 pytest tests/test_decorators.py -v
+pytest tests/test_span_attributes_processor.py -v
 ```
 
 Run with coverage:
@@ -538,6 +601,7 @@ The test suite includes:
 - **PyMySQL instrumentation tests** (`test_pymysql_instrumentation.py`): Database connection instrumentation, query tracing, helper functions
 - **Metrics and logs tests** (`test_metrics_and_logs.py`): Custom metrics creation (counter, histogram, gauge), logging levels (info, warning, debug, error)
 - **Decorators tests** (`test_decorators.py`): Lambda handler decorator, AWS message handler decorator, traces decorator, aws_message_span context manager
+- **Span attributes processor tests** (`test_span_attributes_processor.py`): Automatic span attributes from OTEL_SPAN_ATTRIBUTES (31 tests)
 
 ## License
 

{rebrandly_otel-0.2.17 → rebrandly_otel-0.2.19}/rebrandly_otel.egg-info/SOURCES.txt

@@ -15,10 +15,12 @@ src/metrics.py
 src/otel_utils.py
 src/pymysql_instrumentation.py
 src/rebrandly_otel.py
+src/span_attributes_processor.py
 src/traces.py
 tests/test_decorators.py
 tests/test_fastapi_support.py
 tests/test_flask_support.py
 tests/test_metrics_and_logs.py
 tests/test_pymysql_instrumentation.py
+tests/test_span_attributes_processor.py
 tests/test_usage.py

{rebrandly_otel-0.2.17 → rebrandly_otel-0.2.19}/setup.py

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

rebrandly_otel-0.2.19/src/span_attributes_processor.py

@@ -0,0 +1,106 @@
+"""
+Span Attributes Processor for Rebrandly OTEL SDK
+Automatically adds attributes from OTEL_SPAN_ATTRIBUTES environment variable to all spans
+"""
+
+import os
+from typing import Optional
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace import ReadableSpan, Span
+from opentelemetry.sdk.trace.export import SpanProcessor
+
+
+class SpanAttributesProcessor(SpanProcessor):
+    """
+    Span processor that automatically adds attributes from OTEL_SPAN_ATTRIBUTES
+    environment variable to all spans at creation time.
+    """
+
+    def __init__(self):
+        """Initialize the processor and parse OTEL_SPAN_ATTRIBUTES."""
+        self.name = 'SpanAttributesProcessor'
+        self.span_attributes = self._parse_span_attributes()
+
+        # Log parsed attributes in debug mode
+        if os.environ.get('OTEL_DEBUG', 'false').lower() == 'true' and self.span_attributes:
+            print(f'[SpanAttributesProcessor] Parsed OTEL_SPAN_ATTRIBUTES: {self.span_attributes}')
+
+    def _parse_span_attributes(self) -> dict:
+        """
+        Parse OTEL_SPAN_ATTRIBUTES environment variable.
+        Format: key1=value1,key2=value2
+
+        Returns:
+            Dictionary of parsed attributes as key-value pairs
+        """
+        attributes = {}
+        otel_span_attrs = os.environ.get('OTEL_SPAN_ATTRIBUTES', None)
+
+        if not otel_span_attrs or otel_span_attrs.strip() == '':
+            return attributes
+
+        try:
+            pairs = otel_span_attrs.split(',')
+            for attr in pairs:
+                trimmed_attr = attr.strip()
+                if trimmed_attr and '=' in trimmed_attr:
+                    # Split on first '=' only, in case value contains '='
+                    key, value = trimmed_attr.split('=', 1)
+                    key = key.strip()
+                    value = value.strip()
+                    if key:
+                        attributes[key] = value
+        except Exception as e:
+            print(f'[SpanAttributesProcessor] Warning: Invalid OTEL_SPAN_ATTRIBUTES value: {e}')
+
+        return attributes
+
+    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
+        """
+        Called when a span is started.
+        Adds configured attributes to the span.
+
+        Args:
+            span: The span that was just started
+            parent_context: The parent context (optional)
+        """
+        try:
+            # Add all parsed attributes to the span
+            if self.span_attributes:
+                for key, value in self.span_attributes.items():
+                    span.set_attribute(key, value)
+        except Exception as e:
+            # Fail silently to avoid breaking the entire tracing pipeline
+            # Log only in debug mode to avoid noise
+            if os.environ.get('OTEL_DEBUG', 'false').lower() == 'true':
+                print(f'[SpanAttributesProcessor] Error processing span: {e}')
+
+    def on_end(self, span: ReadableSpan) -> None:
+        """
+        Called when a span is ended.
+        No-op for this processor.
+
+        Args:
+            span: The span that was just ended
+        """
+        pass
+
+    def shutdown(self) -> None:
+        """
+        Shutdown the processor.
+        No-op for this processor.
+        """
+        pass
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """
+        Force flush the processor.
+        No-op for this processor.
+
+        Args:
+            timeout_millis: Maximum time to wait for flush in milliseconds
+
+        Returns:
+            Always returns True as there's nothing to flush
+        """
+        return True

{rebrandly_otel-0.2.17 → rebrandly_otel-0.2.19}/src/traces.py

@@ -12,6 +12,7 @@ from opentelemetry.sdk.trace.export import (
 )
 
 from .otel_utils import *
+from .span_attributes_processor import SpanAttributesProcessor
 
 class RebrandlyTracer:
     """Wrapper for OpenTelemetry tracing with Rebrandly-specific features."""
@@ -26,6 +27,9 @@ class RebrandlyTracer:
         # Create provider with resource
         self._provider = TracerProvider(resource=create_resource())
 
+        # Add span attributes processor to automatically add OTEL_SPAN_ATTRIBUTES to all spans
+        self._provider.add_span_processor(SpanAttributesProcessor())
+
         # Add console exporter for local debugging
         if is_otel_debug():
             console_exporter = ConsoleSpanExporter()

rebrandly_otel-0.2.19/tests/test_span_attributes_processor.py

@@ -0,0 +1,409 @@
+"""
+Tests for SpanAttributesProcessor
+Tests automatic addition of attributes from OTEL_SPAN_ATTRIBUTES to all spans
+"""
+
+import pytest
+import os
+from unittest.mock import MagicMock, patch
+from src.span_attributes_processor import SpanAttributesProcessor
+
+
+class TestSpanAttributesProcessor:
+    """Test SpanAttributesProcessor functionality"""
+
+    def setup_method(self):
+        """Setup method to clear environment before each test"""
+        # Save original environment
+        self.original_env = os.environ.get('OTEL_SPAN_ATTRIBUTES')
+        self.original_debug = os.environ.get('OTEL_DEBUG')
+
+    def teardown_method(self):
+        """Teardown method to restore environment after each test"""
+        # Restore original environment
+        if self.original_env is not None:
+            os.environ['OTEL_SPAN_ATTRIBUTES'] = self.original_env
+        elif 'OTEL_SPAN_ATTRIBUTES' in os.environ:
+            del os.environ['OTEL_SPAN_ATTRIBUTES']
+
+        if self.original_debug is not None:
+            os.environ['OTEL_DEBUG'] = self.original_debug
+        elif 'OTEL_DEBUG' in os.environ:
+            del os.environ['OTEL_DEBUG']
+
+    # ===== Processor Initialization Tests =====
+
+    def test_initialize_without_otel_span_attributes(self):
+        """Test processor initialization without OTEL_SPAN_ATTRIBUTES"""
+        if 'OTEL_SPAN_ATTRIBUTES' in os.environ:
+            del os.environ['OTEL_SPAN_ATTRIBUTES']
+
+        processor = SpanAttributesProcessor()
+
+        assert processor is not None
+        assert processor.name == 'SpanAttributesProcessor'
+        assert processor.span_attributes == {}
+
+    def test_parse_single_attribute(self):
+        """Test parsing a single attribute"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {'team': 'backend'}
+
+    def test_parse_multiple_attributes(self):
+        """Test parsing multiple attributes"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend,environment=production,version=1.2.3'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'team': 'backend',
+            'environment': 'production',
+            'version': '1.2.3'
+        }
+
+    def test_handle_attributes_with_spaces(self):
+        """Test handling attributes with spaces"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team = backend , environment = production'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'team': 'backend',
+            'environment': 'production'
+        }
+
+    def test_handle_attributes_with_equals_in_values(self):
+        """Test handling attributes with equals signs in values"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'url=http://example.com?foo=bar,key=value'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'url': 'http://example.com?foo=bar',
+            'key': 'value'
+        }
+
+    def test_ignore_empty_string(self):
+        """Test ignoring empty string"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = ''
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {}
+
+    def test_ignore_whitespace_only_string(self):
+        """Test ignoring whitespace-only string"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = '   '
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {}
+
+    def test_ignore_malformed_attributes_without_equals(self):
+        """Test ignoring malformed attributes without equals"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend,invalid,version=1.0'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'team': 'backend',
+            'version': '1.0'
+        }
+
+    def test_ignore_attributes_with_empty_keys(self):
+        """Test ignoring attributes with empty keys"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = '=value,team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {'team': 'backend'}
+
+    def test_allow_empty_values(self):
+        """Test allowing empty values"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=,environment=production'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'team': '',
+            'environment': 'production'
+        }
+
+    def test_handle_trailing_commas(self):
+        """Test handling trailing commas"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend,environment=production,'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'team': 'backend',
+            'environment': 'production'
+        }
+
+    # ===== Span Processing Tests =====
+
+    def test_add_attributes_to_span_on_start(self):
+        """Test adding attributes to span on start"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend,environment=production,version=1.2.3'
+
+        processor = SpanAttributesProcessor()
+
+        # Create mock span
+        mock_span = MagicMock()
+
+        # Call on_start
+        processor.on_start(mock_span)
+
+        # Verify set_attribute was called for each attribute
+        assert mock_span.set_attribute.call_count == 3
+        mock_span.set_attribute.assert_any_call('team', 'backend')
+        mock_span.set_attribute.assert_any_call('environment', 'production')
+        mock_span.set_attribute.assert_any_call('version', '1.2.3')
+
+    def test_no_attributes_added_when_none_configured(self):
+        """Test that no attributes are added when none configured"""
+        if 'OTEL_SPAN_ATTRIBUTES' in os.environ:
+            del os.environ['OTEL_SPAN_ATTRIBUTES']
+
+        processor = SpanAttributesProcessor()
+
+        # Create mock span
+        mock_span = MagicMock()
+
+        # Call on_start
+        processor.on_start(mock_span)
+
+        # Verify set_attribute was not called
+        mock_span.set_attribute.assert_not_called()
+
+    def test_handle_set_attribute_errors_gracefully(self):
+        """Test handling set_attribute errors gracefully"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Create mock span that raises error
+        mock_span = MagicMock()
+        mock_span.set_attribute.side_effect = Exception('Test error')
+
+        # Should not raise
+        processor.on_start(mock_span)
+
+    def test_on_end_does_nothing(self):
+        """Test that on_end does nothing"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Create mock span
+        mock_span = MagicMock()
+
+        # Should not raise
+        processor.on_end(mock_span)
+
+    # ===== Lifecycle Methods Tests =====
+
+    def test_shutdown_method(self):
+        """Test shutdown method"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Should not raise
+        processor.shutdown()
+
+    def test_force_flush_method(self):
+        """Test force_flush method"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Should return True
+        result = processor.force_flush()
+        assert result is True
+
+    def test_force_flush_with_timeout(self):
+        """Test force_flush with custom timeout"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Should return True regardless of timeout
+        result = processor.force_flush(timeout_millis=10000)
+        assert result is True
+
+    # ===== Debug Mode Tests =====
+
+    @patch('builtins.print')
+    def test_log_parsed_attributes_when_debug_true(self, mock_print):
+        """Test logging parsed attributes when OTEL_DEBUG is true"""
+        os.environ['OTEL_DEBUG'] = 'true'
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend,env=prod'
+
+        processor = SpanAttributesProcessor()
+
+        # Verify print was called with correct message
+        mock_print.assert_called_with(
+            '[SpanAttributesProcessor] Parsed OTEL_SPAN_ATTRIBUTES: {\'team\': \'backend\', \'env\': \'prod\'}'
+        )
+
+    @patch('builtins.print')
+    def test_no_log_when_debug_false(self, mock_print):
+        """Test not logging when OTEL_DEBUG is false"""
+        os.environ['OTEL_DEBUG'] = 'false'
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Verify print was not called
+        mock_print.assert_not_called()
+
+    @patch('builtins.print')
+    def test_no_log_when_attributes_empty(self, mock_print):
+        """Test not logging when attributes are empty"""
+        os.environ['OTEL_DEBUG'] = 'true'
+        if 'OTEL_SPAN_ATTRIBUTES' in os.environ:
+            del os.environ['OTEL_SPAN_ATTRIBUTES']
+
+        processor = SpanAttributesProcessor()
+
+        # Verify print was not called
+        mock_print.assert_not_called()
+
+    # ===== Error Handling Tests =====
+
+    def test_handle_none_span_gracefully(self):
+        """Test handling None span gracefully"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Should not raise
+        processor.on_start(None)
+
+    @patch('builtins.print')
+    def test_log_errors_in_debug_mode(self, mock_print):
+        """Test logging errors in debug mode when set_attribute fails"""
+        os.environ['OTEL_DEBUG'] = 'true'
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'team=backend'
+
+        processor = SpanAttributesProcessor()
+
+        # Create mock span that raises error
+        mock_span = MagicMock()
+        mock_span.set_attribute.side_effect = Exception('Test error')
+
+        # Call on_start
+        processor.on_start(mock_span)
+
+        # Verify error was logged
+        assert any('[SpanAttributesProcessor] Error processing span:' in str(call)
+                   for call in mock_print.call_args_list)
+
+    # ===== Integration Tests =====
+
+    def test_processor_with_real_span(self):
+        """Test processor works with real span creation"""
+        from opentelemetry import trace
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter
+
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'test=integration'
+
+        # Create provider and add processor
+        provider = TracerProvider()
+        provider.add_span_processor(SpanAttributesProcessor())
+
+        # Set as global
+        trace.set_tracer_provider(provider)
+
+        # Create tracer and span
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span('test-span') as span:
+            # Span should have the attribute
+            assert span is not None
+            # We can't directly verify attributes on the span object,
+            # but we can verify no errors occurred
+
+    def test_processor_name_property(self):
+        """Test processor has correct name property"""
+        processor = SpanAttributesProcessor()
+        assert processor.name == 'SpanAttributesProcessor'
+
+    def test_multiple_processors_can_coexist(self):
+        """Test multiple processors can coexist"""
+        from opentelemetry.sdk.trace import TracerProvider
+
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'test=multi'
+
+        provider = TracerProvider()
+
+        # Add multiple span attributes processors
+        processor1 = SpanAttributesProcessor()
+        processor2 = SpanAttributesProcessor()
+
+        provider.add_span_processor(processor1)
+        provider.add_span_processor(processor2)
+
+        # Should not raise
+        assert True
+
+    # ===== Special Character Tests =====
+
+    def test_handle_special_characters_in_values(self):
+        """Test handling special characters in values"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'msg=Hello, World!,path=/api/v1/users'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'msg': 'Hello',
+            'path': '/api/v1/users'
+        }
+
+    def test_handle_unicode_characters(self):
+        """Test handling unicode characters"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'emoji=🚀,name=José'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'emoji': '🚀',
+            'name': 'José'
+        }
+
+    def test_handle_numeric_values_as_strings(self):
+        """Test that numeric values are treated as strings"""
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = 'port=8080,version=1.0'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {
+            'port': '8080',
+            'version': '1.0'
+        }
+
+    # ===== Edge Case Tests =====
+
+    def test_very_long_attribute_value(self):
+        """Test handling very long attribute values"""
+        long_value = 'a' * 1000
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = f'long={long_value}'
+
+        processor = SpanAttributesProcessor()
+
+        assert processor.span_attributes == {'long': long_value}
+
+    def test_many_attributes(self):
+        """Test handling many attributes"""
+        attrs = ','.join([f'key{i}=value{i}' for i in range(50)])
+        os.environ['OTEL_SPAN_ATTRIBUTES'] = attrs
+
+        processor = SpanAttributesProcessor()
+
+        assert len(processor.span_attributes) == 50
+        assert processor.span_attributes['key0'] == 'value0'
+        assert processor.span_attributes['key49'] == 'value49'