robotframework-tracer 0.1.0__py3-none-any.whl

robotframework_tracer/__init__.py

@@ -0,0 +1,6 @@
+"""Robot Framework Tracer - OpenTelemetry distributed tracing for Robot Framework."""
+
+from .listener import TracingListener
+from .version import __version__
+
+__all__ = ["TracingListener", "__version__"]

robotframework_tracer/attributes.py

@@ -0,0 +1,108 @@
+class RFAttributes:
+    """OpenTelemetry semantic conventions for Robot Framework."""
+
+    # Suite attributes
+    SUITE_NAME = "rf.suite.name"
+    SUITE_SOURCE = "rf.suite.source"
+    SUITE_ID = "rf.suite.id"
+    SUITE_METADATA = "rf.suite.metadata"
+
+    # Test attributes
+    TEST_NAME = "rf.test.name"
+    TEST_ID = "rf.test.id"
+    TEST_TAGS = "rf.test.tags"
+    TEST_TEMPLATE = "rf.test.template"
+    TEST_TIMEOUT = "rf.test.timeout"
+
+    # Keyword attributes
+    KEYWORD_NAME = "rf.keyword.name"
+    KEYWORD_TYPE = "rf.keyword.type"
+    KEYWORD_LIBRARY = "rf.keyword.library"
+    KEYWORD_ARGS = "rf.keyword.args"
+
+    # Result attributes
+    STATUS = "rf.status"
+    ELAPSED_TIME = "rf.elapsed_time"
+    START_TIME = "rf.start_time"
+    END_TIME = "rf.end_time"
+    MESSAGE = "rf.message"
+
+    # Framework attributes
+    RF_VERSION = "rf.version"
+
+
+class AttributeExtractor:
+    """Extract attributes from Robot Framework objects."""
+
+    @staticmethod
+    def from_suite(data, result):
+        """Extract attributes from suite data and result."""
+        attrs = {
+            RFAttributes.SUITE_NAME: data.name,
+            RFAttributes.SUITE_ID: result.id,
+        }
+        if data.source:
+            attrs[RFAttributes.SUITE_SOURCE] = str(data.source)
+        
+        # Extract suite metadata
+        if hasattr(data, 'metadata') and data.metadata:
+            for key, value in data.metadata.items():
+                attrs[f"{RFAttributes.SUITE_METADATA}.{key}"] = str(value)
+        
+        # Add timing information
+        if hasattr(result, 'starttime') and result.starttime:
+            attrs[RFAttributes.START_TIME] = result.starttime
+        if hasattr(result, 'endtime') and result.endtime:
+            attrs[RFAttributes.END_TIME] = result.endtime
+            
+        return attrs
+
+    @staticmethod
+    def from_test(data, result):
+        """Extract attributes from test data and result."""
+        attrs = {
+            RFAttributes.TEST_NAME: data.name,
+            RFAttributes.TEST_ID: result.id,
+        }
+        if data.tags:
+            attrs[RFAttributes.TEST_TAGS] = list(data.tags)
+        
+        # Add test template if available
+        if hasattr(data, 'template') and data.template:
+            attrs[RFAttributes.TEST_TEMPLATE] = str(data.template)
+        
+        # Add test timeout if available
+        if hasattr(data, 'timeout') and data.timeout:
+            attrs[RFAttributes.TEST_TIMEOUT] = str(data.timeout)
+        
+        # Add timing information
+        if hasattr(result, 'starttime') and result.starttime:
+            attrs[RFAttributes.START_TIME] = result.starttime
+        if hasattr(result, 'endtime') and result.endtime:
+            attrs[RFAttributes.END_TIME] = result.endtime
+        
+        # Add message if available
+        if hasattr(result, 'message') and result.message:
+            attrs[RFAttributes.MESSAGE] = result.message
+            
+        return attrs
+
+    @staticmethod
+    def from_keyword(data, result, max_arg_length=200):
+        """Extract attributes from keyword data and result."""
+        attrs = {
+            RFAttributes.KEYWORD_NAME: data.name,
+            RFAttributes.KEYWORD_TYPE: data.type,
+        }
+        # Try to get library name (may not always be available)
+        if hasattr(data, 'libname') and data.libname:
+            attrs[RFAttributes.KEYWORD_LIBRARY] = data.libname
+        elif hasattr(data, 'owner') and data.owner:
+            attrs[RFAttributes.KEYWORD_LIBRARY] = data.owner.name if hasattr(data.owner, 'name') else str(data.owner)
+        
+        if data.args:
+            args_str = ", ".join(str(arg)[:max_arg_length] for arg in data.args[:10])
+            if len(args_str) > max_arg_length:
+                args_str = args_str[:max_arg_length] + "..."
+            attrs[RFAttributes.KEYWORD_ARGS] = args_str
+        return attrs

robotframework_tracer/config.py

@@ -0,0 +1,63 @@
+import os
+
+
+class TracerConfig:
+    """Configuration for the Robot Framework tracer."""
+
+    def __init__(self, **kwargs):
+        self.endpoint = self._get_config(
+            "endpoint", kwargs, "OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4318/v1/traces"
+        )
+        self.service_name = self._get_config(
+            "service_name", kwargs, "OTEL_SERVICE_NAME", "rf"
+        )
+        self.protocol = self._get_config("protocol", kwargs, "RF_TRACER_PROTOCOL", "http")
+        self.capture_arguments = self._get_bool_config(
+            "capture_arguments", kwargs, "RF_TRACER_CAPTURE_ARGUMENTS", True
+        )
+        self.max_arg_length = int(
+            self._get_config("max_arg_length", kwargs, "RF_TRACER_MAX_ARG_LENGTH", "200")
+        )
+        self.capture_logs = self._get_bool_config(
+            "capture_logs", kwargs, "RF_TRACER_CAPTURE_LOGS", False
+        )
+        self.log_level = self._get_config(
+            "log_level", kwargs, "RF_TRACER_LOG_LEVEL", "INFO"
+        ).upper()
+        self.max_log_length = int(
+            self._get_config("max_log_length", kwargs, "RF_TRACER_MAX_LOG_LENGTH", "500")
+        )
+        self.sample_rate = float(
+            self._get_config("sample_rate", kwargs, "RF_TRACER_SAMPLE_RATE", "1.0")
+        )
+        self.span_prefix_style = self._get_config(
+            "span_prefix_style", kwargs, "RF_TRACER_SPAN_PREFIX_STYLE", "none"
+        ).lower()
+
+    def _get_config(self, key, kwargs, env_var, default):
+        """Get configuration value with precedence: kwargs > env > default."""
+        return kwargs.get(key, os.environ.get(env_var, default))
+
+    def _get_bool_config(self, key, kwargs, env_var, default):
+        """Get boolean configuration value."""
+        value = self._get_config(key, kwargs, env_var, str(default))
+        if isinstance(value, bool):
+            return value
+        return value.lower() in ("true", "1", "yes")
+
+    @staticmethod
+    def from_listener_args(*args):
+        """Parse listener arguments from Robot Framework.
+
+        Args can be passed as:
+        - Single string: "endpoint=http://localhost:4318,service_name=my-service"
+        - Multiple strings: "endpoint=http://localhost:4318", "service_name=my-service"
+        """
+        kwargs = {}
+        for arg in args:
+            if "=" in arg:
+                for pair in arg.split(","):
+                    if "=" in pair:
+                        key, value = pair.split("=", 1)
+                        kwargs[key.strip()] = value.strip()
+        return TracerConfig(**kwargs)

robotframework_tracer/listener.py

@@ -0,0 +1,236 @@
+from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as HTTPExporter
+from opentelemetry.sdk.resources import Resource, SERVICE_NAME, SERVICE_VERSION
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.sampling import TraceIdRatioBased, ParentBased
+from opentelemetry.semconv.resource import ResourceAttributes
+import platform
+import sys
+import robot
+
+from .config import TracerConfig
+from .span_builder import SpanBuilder
+
+# Try to import gRPC exporter (optional dependency)
+try:
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter as GRPCExporter
+    GRPC_AVAILABLE = True
+except ImportError:
+    GRPC_AVAILABLE = False
+
+
+class TracingListener:
+    """Robot Framework Listener v3 for distributed tracing."""
+
+    ROBOT_LISTENER_API_VERSION = 3
+
+    def __init__(self, endpoint=None, service_name=None, protocol=None, 
+                 capture_arguments=None, max_arg_length=None, capture_logs=None, 
+                 sample_rate=None, span_prefix_style=None, log_level=None, max_log_length=None):
+        """Initialize the tracing listener.
+
+        Args:
+            endpoint: OTLP endpoint URL
+            service_name: Service name for traces
+            protocol: Protocol (http or grpc)
+            capture_arguments: Whether to capture keyword arguments
+            max_arg_length: Maximum length for arguments
+            capture_logs: Whether to capture log messages
+            sample_rate: Sampling rate (0.0-1.0)
+            span_prefix_style: Span prefix style (none, text, emoji)
+            log_level: Minimum log level to capture (DEBUG, INFO, WARN, ERROR)
+            max_log_length: Maximum length for log messages
+        """
+        # Build kwargs dict from provided arguments
+        kwargs = {}
+        if endpoint is not None:
+            kwargs['endpoint'] = endpoint
+        if service_name is not None:
+            kwargs['service_name'] = service_name
+        if protocol is not None:
+            kwargs['protocol'] = protocol
+        if capture_arguments is not None:
+            kwargs['capture_arguments'] = capture_arguments
+        if max_arg_length is not None:
+            kwargs['max_arg_length'] = max_arg_length
+        if capture_logs is not None:
+            kwargs['capture_logs'] = capture_logs
+        if sample_rate is not None:
+            kwargs['sample_rate'] = sample_rate
+        if span_prefix_style is not None:
+            kwargs['span_prefix_style'] = span_prefix_style
+        if log_level is not None:
+            kwargs['log_level'] = log_level
+        if max_log_length is not None:
+            kwargs['max_log_length'] = max_log_length
+            
+        self.config = TracerConfig(**kwargs)
+
+        # Initialize OpenTelemetry with automatic resource detection
+        resource_attrs = {
+            SERVICE_NAME: self.config.service_name,
+            ResourceAttributes.TELEMETRY_SDK_NAME: "robotframework-tracer",
+            ResourceAttributes.TELEMETRY_SDK_LANGUAGE: "python",
+            ResourceAttributes.TELEMETRY_SDK_VERSION: "0.1.0",
+            "rf.version": robot.version.get_version(),
+            "python.version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            ResourceAttributes.HOST_NAME: platform.node(),
+            ResourceAttributes.OS_TYPE: platform.system(),
+            ResourceAttributes.OS_VERSION: platform.release(),
+        }
+        resource = Resource.create(resource_attrs)
+        
+        # Configure sampling only if sample_rate < 1.0
+        if self.config.sample_rate < 1.0:
+            sampler = ParentBased(root=TraceIdRatioBased(self.config.sample_rate))
+            provider = TracerProvider(resource=resource, sampler=sampler)
+        else:
+            provider = TracerProvider(resource=resource)
+        
+        # Select exporter based on protocol
+        if self.config.protocol == "grpc":
+            if not GRPC_AVAILABLE:
+                print("Warning: gRPC exporter not available. Install with: pip install opentelemetry-exporter-otlp-proto-grpc")
+                print("Falling back to HTTP exporter")
+                exporter = HTTPExporter(endpoint=self.config.endpoint)
+            else:
+                exporter = GRPCExporter(endpoint=self.config.endpoint)
+        else:
+            exporter = HTTPExporter(endpoint=self.config.endpoint)
+        
+        processor = BatchSpanProcessor(exporter)
+        provider.add_span_processor(processor)
+        trace.set_tracer_provider(provider)
+
+        self.tracer = trace.get_tracer(__name__)
+        self.span_stack = []
+
+    def start_suite(self, data, result):
+        """Create root span for suite."""
+        try:
+            span = SpanBuilder.create_suite_span(self.tracer, data, result, self.config.span_prefix_style)
+            self.span_stack.append(span)
+        except Exception as e:
+            print(f"TracingListener error in start_suite: {e}")
+
+    def end_suite(self, data, result):
+        """Close suite span."""
+        try:
+            if self.span_stack:
+                span = self.span_stack.pop()
+                SpanBuilder.set_span_status(span, result)
+                span.end()
+        except Exception as e:
+            print(f"TracingListener error in end_suite: {e}")
+
+    def start_test(self, data, result):
+        """Create child span for test case."""
+        try:
+            parent_context = (
+                trace.set_span_in_context(self.span_stack[-1]) if self.span_stack else None
+            )
+            span = SpanBuilder.create_test_span(self.tracer, data, result, parent_context, self.config.span_prefix_style)
+            self.span_stack.append(span)
+        except Exception as e:
+            print(f"TracingListener error in start_test: {e}")
+
+    def end_test(self, data, result):
+        """Close test span with verdict."""
+        try:
+            if self.span_stack:
+                span = self.span_stack.pop()
+                SpanBuilder.set_span_status(span, result)
+                if result.status == "FAIL":
+                    SpanBuilder.add_error_event(span, result)
+                span.end()
+        except Exception as e:
+            print(f"TracingListener error in end_test: {e}")
+
+    def start_keyword(self, data, result):
+        """Create child span for keyword/step."""
+        try:
+            if not self.config.capture_arguments and data.args:
+                return
+
+            parent_context = (
+                trace.set_span_in_context(self.span_stack[-1]) if self.span_stack else None
+            )
+            span = SpanBuilder.create_keyword_span(
+                self.tracer, data, result, parent_context, self.config.max_arg_length, self.config.span_prefix_style
+            )
+            self.span_stack.append(span)
+            
+            # Add event for setup/teardown start
+            if data.type in ("SETUP", "TEARDOWN"):
+                span.add_event(f"{data.type.lower()}.start", {"keyword": data.name})
+        except Exception as e:
+            print(f"TracingListener error in start_keyword: {e}")
+
+    def end_keyword(self, data, result):
+        """Close keyword span."""
+        try:
+            if self.span_stack:
+                span = self.span_stack.pop()
+                
+                # Add event for setup/teardown end
+                if data.type in ("SETUP", "TEARDOWN"):
+                    span.add_event(f"{data.type.lower()}.end", {
+                        "keyword": data.name,
+                        "status": result.status
+                    })
+                
+                SpanBuilder.set_span_status(span, result)
+                if result.status == "FAIL":
+                    SpanBuilder.add_error_event(span, result)
+                span.end()
+        except Exception as e:
+            print(f"TracingListener error in end_keyword: {e}")
+
+    def close(self):
+        """Cleanup on listener close."""
+        try:
+            while self.span_stack:
+                span = self.span_stack.pop()
+                span.end()
+            trace.get_tracer_provider().force_flush()
+        except Exception as e:
+            print(f"TracingListener error in close: {e}")
+
+    def log_message(self, message):
+        """Capture log messages as span events."""
+        try:
+            if not self.config.capture_logs or not self.span_stack:
+                return
+            
+            # Filter by log level
+            log_levels = {"TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3, "ERROR": 4, "FAIL": 5}
+            min_level = log_levels.get(self.config.log_level, 2)
+            msg_level = log_levels.get(message.level, 2)
+            
+            if msg_level < min_level:
+                return
+            
+            # Get current span
+            current_span = self.span_stack[-1]
+            
+            # Limit message length
+            log_text = message.message
+            if len(log_text) > self.config.max_log_length:
+                log_text = log_text[:self.config.max_log_length] + "..."
+            
+            # Add log as span event (convert timestamp to string)
+            event_attrs = {
+                "message": log_text,
+                "level": message.level,
+            }
+            if hasattr(message, 'timestamp') and message.timestamp:
+                event_attrs["timestamp"] = str(message.timestamp)
+            
+            current_span.add_event(f"log.{message.level.lower()}", event_attrs)
+        except RecursionError:
+            # Avoid infinite recursion if logging causes more logs
+            pass
+        except Exception:
+            # Silently ignore errors in log capture to avoid breaking tests
+            pass

robotframework_tracer/span_builder.py

@@ -0,0 +1,128 @@
+from opentelemetry import trace, baggage
+from opentelemetry.trace import Status, StatusCode
+import robot
+
+from .attributes import AttributeExtractor, RFAttributes
+
+
+class SpanBuilder:
+    """Build OpenTelemetry spans from Robot Framework objects."""
+
+    # Prefix mappings
+    TEXT_PREFIXES = {
+        "SUITE": "[SUITE]",
+        "TEST": "[TEST CASE]",
+        "KEYWORD": "[TEST STEP]",
+        "SETUP": "[SETUP]",
+        "TEARDOWN": "[TEARDOWN]",
+    }
+
+    EMOJI_PREFIXES = {
+        "SUITE": "📦",
+        "TEST": "🧪",
+        "KEYWORD": "👟",
+        "SETUP": "🔧",
+        "TEARDOWN": "🧹",
+    }
+
+    @staticmethod
+    def _add_prefix(name, span_type, prefix_style):
+        """Add prefix to span name based on style."""
+        if prefix_style == "none" or not prefix_style:
+            return name
+        elif prefix_style == "text":
+            prefix = SpanBuilder.TEXT_PREFIXES.get(span_type, "")
+            return f"{prefix} {name}" if prefix else name
+        elif prefix_style == "emoji":
+            prefix = SpanBuilder.EMOJI_PREFIXES.get(span_type, "")
+            return f"{prefix} {name}" if prefix else name
+        return name
+
+    @staticmethod
+    def create_suite_span(tracer, data, result, prefix_style="none"):
+        """Create root span for test suite."""
+        attrs = AttributeExtractor.from_suite(data, result)
+        name = SpanBuilder._add_prefix(data.name, "SUITE", prefix_style)
+        
+        # Create context with baggage
+        ctx = baggage.set_baggage("rf.suite.id", result.id)
+        ctx = baggage.set_baggage("rf.version", robot.version.get_version(), ctx)
+        
+        # Add suite metadata to baggage (limit to avoid too much data)
+        if hasattr(data, 'metadata') and data.metadata:
+            for key, value in list(data.metadata.items())[:5]:  # Limit to 5 metadata items
+                ctx = baggage.set_baggage(f"rf.suite.metadata.{key}", str(value), ctx)
+        
+        span = tracer.start_span(name, context=ctx, kind=trace.SpanKind.INTERNAL, attributes=attrs)
+        return span
+
+    @staticmethod
+    def create_test_span(tracer, data, result, parent_context, prefix_style="none"):
+        """Create child span for test case."""
+        attrs = AttributeExtractor.from_test(data, result)
+        name = SpanBuilder._add_prefix(data.name, "TEST", prefix_style)
+        span = tracer.start_span(
+            name, context=parent_context, kind=trace.SpanKind.INTERNAL, attributes=attrs
+        )
+        return span
+
+    @staticmethod
+    def create_keyword_span(tracer, data, result, parent_context, max_arg_length=200, prefix_style="none"):
+        """Create child span for keyword."""
+        attrs = AttributeExtractor.from_keyword(data, result, max_arg_length)
+        
+        # Build keyword name with arguments (like RF test step line)
+        kw_name = data.name
+        if data.args:
+            # Join arguments with comma-space
+            args_str = ", ".join(str(arg) for arg in data.args)
+            # Limit total length to avoid extremely long span names
+            if len(args_str) > 100:
+                args_str = args_str[:100] + "..."
+            kw_name = f"{data.name} {args_str}"
+        
+        # Determine span type for prefix
+        if data.type in ("SETUP", "TEARDOWN"):
+            span_type = data.type
+        else:
+            span_type = "KEYWORD"
+        
+        # Add prefix based on style
+        kw_name = SpanBuilder._add_prefix(kw_name, span_type, prefix_style)
+        
+        span = tracer.start_span(
+            kw_name, context=parent_context, kind=trace.SpanKind.INTERNAL, attributes=attrs
+        )
+        return span
+
+    @staticmethod
+    def set_span_status(span, result):
+        """Set span status based on RF result."""
+        span.set_attribute(RFAttributes.STATUS, result.status)
+        span.set_attribute(RFAttributes.ELAPSED_TIME, result.elapsedtime / 1000.0)
+
+        if result.status == "FAIL":
+            span.set_status(Status(StatusCode.ERROR, result.message))
+        else:
+            span.set_status(Status(StatusCode.OK))
+
+    @staticmethod
+    def add_error_event(span, result):
+        """Add error event with exception details."""
+        if result.status == "FAIL" and result.message:
+            # Create detailed error event
+            event_attrs = {
+                "message": result.message,
+                "rf.status": "FAIL",
+            }
+            
+            # Try to extract exception type if available
+            if hasattr(result, 'error') and result.error:
+                event_attrs["exception.type"] = type(result.error).__name__
+                event_attrs["exception.message"] = str(result.error)
+            
+            # Add timestamp
+            if hasattr(result, 'endtime') and result.endtime:
+                event_attrs["timestamp"] = result.endtime
+            
+            span.add_event("test.failed", event_attrs)

robotframework_tracer/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

robotframework_tracer-0.1.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.1
+Name: robotframework-tracer
+Version: 0.1.0
+Summary: OpenTelemetry distributed tracing for Robot Framework
+Author: Robot Framework Tracer Contributors
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/yourusername/robotframework-tracer
+Project-URL: Documentation, https://github.com/yourusername/robotframework-tracer/blob/main/README.md
+Project-URL: Repository, https://github.com/yourusername/robotframework-tracer
+Project-URL: Issues, https://github.com/yourusername/robotframework-tracer/issues
+Keywords: robotframework,testing,tracing,opentelemetry,observability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: Robot Framework
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: robotframework>=6.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Provides-Extra: grpc
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.20.0; extra == "grpc"
+
+# Robot Framework Tracer
+
+OpenTelemetry distributed tracing integration for Robot Framework test execution.
+
+## What is this?
+
+`robotframework-tracer` is a Robot Framework listener plugin that automatically creates distributed traces for your test execution using OpenTelemetry. It captures the complete test hierarchy (suites → tests → keywords) as spans and exports them to any OpenTelemetry-compatible backend like Jaeger, Grafana Tempo, or Zipkin.
+
+This enables you to:
+- **Visualize test execution flow** with detailed timing information
+- **Debug test failures** by examining the complete execution trace
+- **Analyze performance** and identify slow keywords or tests
+- **Correlate tests with application traces** in distributed systems
+- **Monitor test execution** across CI/CD pipelines
+
+![Robot Framework Trace Visualization](docs/robotframework-trace.jpg)
+
+## How it works
+
+The tracer implements the Robot Framework Listener v3 API and creates OpenTelemetry spans for each test execution phase:
+
+```
+Suite Span (root)
+├── Test Case Span
+│   ├── Keyword Span
+│   │   └── Nested Keyword Span
+│   └── Keyword Span
+└── Test Case Span
+    └── Keyword Span
+```
+
+Each span includes rich metadata: test names, tags, status (PASS/FAIL), timing, arguments, and error details.
+
+## Installation
+
+### From PyPI (when released)
+
+```bash
+pip install robotframework-tracer
+```
+
+### From Source (Development)
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd robotframework-tracer
+
+# Create and activate virtual environment
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install in development mode
+pip install -e ".[dev]"
+```
+
+See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for detailed development setup instructions.
+
+## Quick Start
+
+### 1. Start a tracing backend (Jaeger example)
+
+```bash
+docker run -d --name jaeger \
+  -p 16686:16686 \
+  -p 4318:4318 \
+  jaegertracing/all-in-one:latest
+```
+
+### 2. Run your tests with the listener
+
+```bash
+robot --listener robotframework_tracer.TracingListener tests/
+```
+
+### 3. View traces
+
+Open http://localhost:16686 in your browser to see your test traces in Jaeger UI.
+
+## Configuration
+
+### Basic usage
+
+```bash
+robot --listener robotframework_tracer.TracingListener tests/
+```
+
+### Custom endpoint
+
+```bash
+robot --listener robotframework_tracer.TracingListener:endpoint=http://jaeger:4318/v1/traces tests/
+```
+
+### Custom service name
+
+```bash
+robot --listener "robotframework_tracer.TracingListener:endpoint=http://jaeger:4318/v1/traces,service_name=my-tests" tests/
+```
+
+### All configuration options
+
+```bash
+robot --listener "robotframework_tracer.TracingListener:\
+endpoint=http://localhost:4318/v1/traces,\
+service_name=robot-tests,\
+protocol=http,\
+capture_arguments=true,\
+max_arg_length=200" tests/
+```
+
+### Environment variables
+
+```bash
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+export OTEL_SERVICE_NAME=robot-framework-tests
+robot --listener robotframework_tracer.TracingListener tests/
+```
+
+## Configuration Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `endpoint` | `http://localhost:4318/v1/traces` | OTLP endpoint URL |
+| `service_name` | `rf` | Service name in traces |
+| `protocol` | `http` | Protocol: `http` or `grpc` |
+| `span_prefix_style` | `none` | Span prefix style: `none`, `text`, `emoji` |
+| `capture_arguments` | `true` | Capture keyword arguments |
+| `max_arg_length` | `200` | Max length for arguments |
+| `capture_logs` | `false` | Capture log messages as events |
+| `log_level` | `INFO` | Minimum log level (DEBUG, INFO, WARN, ERROR) |
+| `max_log_length` | `500` | Max length for log messages |
+| `sample_rate` | `1.0` | Sampling rate (0.0-1.0, 1.0 = no sampling) |
+
+## Span Attributes
+
+Each span includes relevant Robot Framework metadata:
+
+**Suite spans:**
+- `rf.suite.name` - Suite name
+- `rf.suite.source` - Suite file path
+- `rf.suite.id` - Suite ID
+- `rf.version` - Robot Framework version
+
+**Test spans:**
+- `rf.test.name` - Test case name
+- `rf.test.id` - Test ID
+- `rf.test.tags` - Test tags
+- `rf.status` - PASS/FAIL/SKIP
+- `rf.elapsed_time` - Execution time
+
+**Keyword spans:**
+- `rf.keyword.name` - Keyword name
+- `rf.keyword.type` - SETUP/TEARDOWN/KEYWORD
+- `rf.keyword.library` - Library name
+- `rf.keyword.args` - Arguments (if enabled)
+- `rf.status` - PASS/FAIL
+
+## Supported Backends
+
+Works with any OpenTelemetry-compatible backend:
+- **Jaeger** - Open source tracing platform
+- **Grafana Tempo** - High-scale distributed tracing
+- **Zipkin** - Distributed tracing system
+- **AWS X-Ray** - AWS distributed tracing
+- **Honeycomb** - Observability platform
+- **Datadog** - Monitoring and analytics
+
+See [docs/backends.md](docs/backends.md) for backend-specific setup guides.
+
+## Requirements
+
+- Python 3.8+
+- Robot Framework 6.0+
+- OpenTelemetry SDK
+
+## Documentation
+
+- [Architecture](docs/ARCHITECTURE.md) - Design and architecture details
+- [Implementation Plan](docs/IMPLEMENTATION_PLAN.md) - Development roadmap
+- [Configuration Guide](docs/configuration.md) - Detailed configuration reference
+- [Attribute Reference](docs/attributes.md) - Complete attribute documentation
+- [Backend Setup](docs/backends.md) - Backend-specific guides
+
+## Examples
+
+See the [examples/](examples/) directory for complete examples:
+- Basic usage with Jaeger
+- Advanced configuration
+- CI/CD integration
+- Multiple backend setups
+
+## Contributing
+
+Contributions are welcome! Please see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md) for guidelines.
+
+## License
+
+Apache License 2.0 - See [docs/LICENSE](docs/LICENSE) for details.
+
+## Status
+
+**Current Version:** v0.1.0  
+**Status:** Production-ready MVP
+
+Core functionality is complete and tested. See [docs/CHANGELOG.md](docs/CHANGELOG.md) for version history and [docs/IMPLEMENTATION_PLAN.md](docs/IMPLEMENTATION_PLAN.md) for the development roadmap.

robotframework_tracer-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+robotframework_tracer/__init__.py,sha256=cZh3xnNaYhRisrqqWH5Gdt4zsgpbh1mUALJiUtGNG8M,204
+robotframework_tracer/attributes.py,sha256=7lpqy-7maQma01tfG3TzUNLIseQPzARCuYPFiy1K3ao,3854
+robotframework_tracer/config.py,sha256=qCckfLNvwRUrJ8EolG47zJDmZG-9175V7_1gR4ypNZc,2552
+robotframework_tracer/listener.py,sha256=8FMv2BTFo3Q471dFVCoS0YfLrHkeBSPsH6EKG75ccqQ,9795
+robotframework_tracer/span_builder.py,sha256=NKo0AOS-ZxYY_Z6Oypfbg33CAt2EKt6016Vh8woDtfo,4914
+robotframework_tracer/version.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+robotframework_tracer-0.1.0.dist-info/METADATA,sha256=C60xEMX1xrxLxefDlGggCCzbwd1Nbt_mJI5mXQdyLOY,7654
+robotframework_tracer-0.1.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+robotframework_tracer-0.1.0.dist-info/top_level.txt,sha256=G1sMKH-8SM_CdJe0Wm6wa_rg1uo62jfhft_UfaxZ05I,22
+robotframework_tracer-0.1.0.dist-info/RECORD,,

robotframework_tracer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

robotframework_tracer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+robotframework_tracer