otel-utils 0.1.11__tar.gz

otel_utils-0.1.11/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.3
+Name: otel-utils
+Version: 0.1.11
+Summary: Utilidades simplificadas para instrumentación con OpenTelemetry
+License: Proprietary
+Author: Harold Portocarrero
+Author-email: harold@getcometa.com
+Requires-Python: >=3.8
+Classifier: License :: Other/Proprietary 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: Programming Language :: Python :: 3.13
+Requires-Dist: opentelemetry-api (>=1.29.0)
+Requires-Dist: opentelemetry-exporter-otlp (>=1.29.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.50b0)
+Requires-Dist: opentelemetry-instrumentation-logging (>=0.50b0)
+Requires-Dist: opentelemetry-sdk (>=1.29.0)
+Requires-Dist: typing-extensions (>=4.12.2)
+Project-URL: Repository, https://github.com/getcometa/otel-utils
+Description-Content-Type: text/markdown
+
+# OpenTelemetry Utils
+
+A Python library designed to simplify application instrumentation using OpenTelemetry. This library provides an abstraction layer that makes instrumentation more intuitive and less intrusive in your business logic.
+
+## Features
+
+- Simplified OpenTelemetry configuration
+- Intuitive API for distributed tracing
+- Utilities for metrics and structured logging
+- OpenTelemetry Collector integration
+- Complete context propagation support
+- Full compatibility with asynchronous applications
+
+## Installation
+
+To install the library from the private repository:
+
+```bash
+pip install git+ssh://git@github.com/your-organization/otel-utils.git
+```
+
+Or add this to your requirements.txt:
+```bash
+git+ssh://git@github.com/your-organization/otel-utils.git@v0.1.0
+```
+
+# Basic Usage
+## Initial Configuration
+```python
+from otel_utils import OtelConfig, OtelConfigurator
+
+config = OtelConfig(
+    service_name="my-service",
+    environment="production"
+)
+
+OtelConfigurator(config)
+```
+
+## Tracing
+```python
+from otel_utils import Tracer
+
+tracer = Tracer("my-service")
+
+# Using the decorator
+@tracer.trace("my_operation")
+async def my_function():
+    # Your code here
+    pass
+
+# Using the context manager
+with tracer.create_span("my_operation") as span:
+    span.set_attribute("key", "value")
+    # Your code here
+```
+
+## Metrics
+```python
+from otel_utils import Metrics
+
+metrics = Metrics("my-service")
+
+# Simple counter
+counter = metrics.get_counter("requests_total")
+counter.add(1, {"endpoint": "/api/v1/resource"})
+
+# Histogram for latencies
+with metrics.measure_duration("request_duration"):
+    # Your code here
+    pass
+```
+
+## Structured Logging
+```python
+from otel_utils import StructuredLogger
+
+logger = StructuredLogger("my-service")
+
+with logger.operation_context("process_order", order_id="123"):
+    logger.info("Starting processing")
+    # Your code here
+```
+
+# OpenTelemetry Collector Integration
+This library is designed to work seamlessly with the OpenTelemetry Collector. Telemetry data is sent using the OTLP protocol, which is the OpenTelemetry standard.
+```yaml
+# collector configuration example
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+
+exporters:
+  # configure your exporters here
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      exporters: [your-exporter]
+```
+
+# Best Practices
+## Separation of Concerns
+Keep instrumentation separate from business logic by creating domain-specific abstractions. Your business code should remain clean and focused on its primary responsibilities.
+
+## Consistent Naming
+Use coherent naming conventions for spans, metrics, and logs across your services. This makes it easier to correlate and analyze telemetry data.
+
+## Relevant Context
+Include useful contextual information in spans and logs, but be mindful of sensitive data. Focus on information that aids debugging and monitoring.
+
+## Appropriate Granularity
+Don't instrument everything. Focus on significant operations that provide value for monitoring and debugging. Consider the overhead and noise ratio when adding instrumentation.
+
+# Development
+To set up the development environment:
+    
+```bash
+# Create virtualenv
+python -m venv venv
+source venv/bin/activate  # or `venv\Scripts\activate` on Windows
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+# Contributing
+1. Create a feature branch (`git checkout -b feature/new-feature`)
+2. Commit your changes (`git commit -am 'Add new feature'`)
+3. Push to the branch (`git push origin feature/new-feature`)
+4. Create a Pull Request
+
+I hope this documentation helps you understand and effectively use the OpenTelemetry Utils library. Each section is designed to guide you through the essential aspects of instrumenting your applications while maintaining clean and maintainable code.
+Let me know if you need any clarification or have questions about specific features or use cases. We can explore any aspect of the library in more detail.

otel_utils-0.1.11/README.md

@@ -0,0 +1,142 @@
+# OpenTelemetry Utils
+
+A Python library designed to simplify application instrumentation using OpenTelemetry. This library provides an abstraction layer that makes instrumentation more intuitive and less intrusive in your business logic.
+
+## Features
+
+- Simplified OpenTelemetry configuration
+- Intuitive API for distributed tracing
+- Utilities for metrics and structured logging
+- OpenTelemetry Collector integration
+- Complete context propagation support
+- Full compatibility with asynchronous applications
+
+## Installation
+
+To install the library from the private repository:
+
+```bash
+pip install git+ssh://git@github.com/your-organization/otel-utils.git
+```
+
+Or add this to your requirements.txt:
+```bash
+git+ssh://git@github.com/your-organization/otel-utils.git@v0.1.0
+```
+
+# Basic Usage
+## Initial Configuration
+```python
+from otel_utils import OtelConfig, OtelConfigurator
+
+config = OtelConfig(
+    service_name="my-service",
+    environment="production"
+)
+
+OtelConfigurator(config)
+```
+
+## Tracing
+```python
+from otel_utils import Tracer
+
+tracer = Tracer("my-service")
+
+# Using the decorator
+@tracer.trace("my_operation")
+async def my_function():
+    # Your code here
+    pass
+
+# Using the context manager
+with tracer.create_span("my_operation") as span:
+    span.set_attribute("key", "value")
+    # Your code here
+```
+
+## Metrics
+```python
+from otel_utils import Metrics
+
+metrics = Metrics("my-service")
+
+# Simple counter
+counter = metrics.get_counter("requests_total")
+counter.add(1, {"endpoint": "/api/v1/resource"})
+
+# Histogram for latencies
+with metrics.measure_duration("request_duration"):
+    # Your code here
+    pass
+```
+
+## Structured Logging
+```python
+from otel_utils import StructuredLogger
+
+logger = StructuredLogger("my-service")
+
+with logger.operation_context("process_order", order_id="123"):
+    logger.info("Starting processing")
+    # Your code here
+```
+
+# OpenTelemetry Collector Integration
+This library is designed to work seamlessly with the OpenTelemetry Collector. Telemetry data is sent using the OTLP protocol, which is the OpenTelemetry standard.
+```yaml
+# collector configuration example
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+
+exporters:
+  # configure your exporters here
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      exporters: [your-exporter]
+```
+
+# Best Practices
+## Separation of Concerns
+Keep instrumentation separate from business logic by creating domain-specific abstractions. Your business code should remain clean and focused on its primary responsibilities.
+
+## Consistent Naming
+Use coherent naming conventions for spans, metrics, and logs across your services. This makes it easier to correlate and analyze telemetry data.
+
+## Relevant Context
+Include useful contextual information in spans and logs, but be mindful of sensitive data. Focus on information that aids debugging and monitoring.
+
+## Appropriate Granularity
+Don't instrument everything. Focus on significant operations that provide value for monitoring and debugging. Consider the overhead and noise ratio when adding instrumentation.
+
+# Development
+To set up the development environment:
+    
+```bash
+# Create virtualenv
+python -m venv venv
+source venv/bin/activate  # or `venv\Scripts\activate` on Windows
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+# Contributing
+1. Create a feature branch (`git checkout -b feature/new-feature`)
+2. Commit your changes (`git commit -am 'Add new feature'`)
+3. Push to the branch (`git push origin feature/new-feature`)
+4. Create a Pull Request
+
+I hope this documentation helps you understand and effectively use the OpenTelemetry Utils library. Each section is designed to guide you through the essential aspects of instrumenting your applications while maintaining clean and maintainable code.
+Let me know if you need any clarification or have questions about specific features or use cases. We can explore any aspect of the library in more detail.

otel_utils-0.1.11/pyproject.toml

@@ -0,0 +1,36 @@
+[tool.poetry]
+name = "otel-utils"
+version = "0.1.11"
+description = "Utilidades simplificadas para instrumentación con OpenTelemetry"
+authors = ["Harold Portocarrero <harold@getcometa.com>"]
+readme = "README.md"
+packages = [
+    { include = "otel_utils", from = "src" }
+]
+repository = "https://github.com/getcometa/otel-utils"
+license = "Proprietary"
+
+[tool.poetry.dependencies]
+python = ">=3.8"
+opentelemetry-api = ">=1.29.0"
+opentelemetry-sdk = ">=1.29.0"
+opentelemetry-exporter-otlp = ">=1.29.0"
+opentelemetry-instrumentation = ">=0.50b0"
+opentelemetry-instrumentation-logging = ">=0.50b0"
+typing-extensions = ">=4.12.2"
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=8.3.4"
+pytest-asyncio = ">=0.23.0"
+pytest-cov = ">=4.1.0"
+asyncio = ">=3.4.3"
+black = "<=23.12.1"
+isort = ">=5.13.2"
+mypy = ">=1.14.1"
+ruff = ">=0.9.2"
+twine = ">=6.1.0"
+docutils = "0.20.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

otel_utils-0.1.11/src/otel_utils/configurator.py

@@ -0,0 +1,156 @@
+import logging
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, Literal
+
+from opentelemetry import trace, metrics
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter as GRPCLogExporter
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter as GRPCMetricExporter
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter as GRPCSpanExporter
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter as HTTPLogExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter as HTTPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as HTTPSpanExporter
+from opentelemetry.instrumentation.logging import LoggingInstrumentor
+from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+
+@dataclass
+class OtelConfig:
+    """Configuration for OpenTelemetry instrumentation."""
+    service_name: str
+    environment: str
+    otlp_endpoint: Optional[str] = None
+    protocol: Literal["grpc", "http"] = "grpc"
+    additional_resources: Optional[Dict[str, Any]] = None
+    trace_sample_rate: float = 1.0
+    metric_export_interval_ms: int = 30000
+    log_level: int = logging.INFO
+    enable_console_logging: bool = True
+
+    @property
+    def trace_endpoint(self) -> Optional[str]:
+        if not self.otlp_endpoint:
+            return None
+        return f"{self.otlp_endpoint}/v1/traces" if self.protocol == "http" else self.otlp_endpoint
+
+    @property
+    def metric_endpoint(self) -> Optional[str]:
+        if not self.otlp_endpoint:
+            return None
+        return f"{self.otlp_endpoint}/v1/metrics" if self.protocol == "http" else self.otlp_endpoint
+
+    @property
+    def log_endpoint(self) -> Optional[str]:
+        if not self.otlp_endpoint:
+            return None
+        return f"{self.otlp_endpoint}/v1/logs" if self.protocol == "http" else self.otlp_endpoint
+
+
+class OtelConfigurator:
+    """Central Configurator for OpenTelemetry."""
+
+    def __init__(self, config: OtelConfig):
+        self.config = config
+        self._setup_resource()
+        self._setup_tracing()
+        self._setup_metrics()
+        self._setup_logging()
+
+    def _get_exporters(self):
+        """Get the appropriate exporters based on the protocol."""
+        if not self.config.otlp_endpoint:
+            return None, None, None
+
+        if self.config.protocol == "grpc":
+            return (
+                GRPCSpanExporter(endpoint=self.config.trace_endpoint),
+                GRPCMetricExporter(endpoint=self.config.metric_endpoint),
+                GRPCLogExporter(endpoint=self.config.log_endpoint)
+            )
+        else:
+            return (
+                HTTPSpanExporter(endpoint=self.config.trace_endpoint),
+                HTTPMetricExporter(endpoint=self.config.metric_endpoint),
+                HTTPLogExporter(endpoint=self.config.log_endpoint)
+            )
+
+    def _setup_resource(self) -> None:
+        """Set up the base resource with the service attributes."""
+        resource_attributes = {
+            "service.name": self.config.service_name,
+            "deployment.environment": self.config.environment,
+        }
+        if self.config.additional_resources:
+            resource_attributes.update(self.config.additional_resources)
+
+        self.resource = Resource.create(resource_attributes)
+
+    def _setup_tracing(self) -> None:
+        """Set up the tracing system."""
+        tracer_provider = TracerProvider(resource=self.resource)
+
+        if self.config.otlp_endpoint:
+            span_exporter, _, _ = self._get_exporters()
+            span_processor = BatchSpanProcessor(span_exporter)
+            tracer_provider.add_span_processor(span_processor)
+
+        trace.set_tracer_provider(tracer_provider)
+
+    def _setup_metrics(self) -> None:
+        """Set up the metrics system."""
+        if self.config.otlp_endpoint:
+            _, metric_exporter, _ = self._get_exporters()
+            metric_reader = PeriodicExportingMetricReader(
+                metric_exporter,
+                export_interval_millis=self.config.metric_export_interval_ms
+            )
+            meter_provider = MeterProvider(resource=self.resource, metric_readers=[metric_reader])
+        else:
+            meter_provider = MeterProvider(resource=self.resource)
+
+        metrics.set_meter_provider(meter_provider)
+
+    def _setup_logging(self) -> None:
+        """
+        Set up the logging system with OpenTelemetry integration.
+        """
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers[:]:
+            root_logger.removeHandler(handler)
+
+        service_logger = logging.getLogger(self.config.service_name)
+        for handler in service_logger.handlers[:]:
+            service_logger.removeHandler(handler)
+
+        logging.getLogger('opentelemetry').setLevel(logging.ERROR)
+
+        logger_provider = LoggerProvider(resource=self.resource)
+        if self.config.otlp_endpoint:
+            _, _, log_exporter = self._get_exporters()
+            logger_provider.add_log_record_processor(
+                BatchLogRecordProcessor(log_exporter)
+            )
+
+        set_logger_provider(logger_provider)
+
+        console_handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s %(levelname)s [%(name)s] %(message)s'
+        )
+        console_handler.setFormatter(formatter)
+        root_logger.addHandler(console_handler)
+        root_logger.setLevel(self.config.log_level)
+
+        LoggingInstrumentor().instrument(
+            logger_provider=logger_provider,
+            set_logging_format=True,
+            log_level=self.config.log_level
+        )
+
+        self.logger = logging.getLogger(self.config.service_name)

otel_utils-0.1.11/src/otel_utils/logging.py

@@ -0,0 +1,115 @@
+import logging
+import json
+from datetime import datetime
+from typing import Any, Dict, Optional
+from opentelemetry import trace
+from contextlib import contextmanager
+
+
+class StructuredLogger:
+    """
+    Logger that produces structured logs with tracing context.
+    """
+
+    def __init__(
+            self,
+            service_name: str,
+            default_attributes: Optional[Dict[str, Any]] = None
+    ):
+        self.logger = logging.getLogger(service_name)
+        self.default_attributes = {
+            "service.name": service_name,
+            **(default_attributes or {})
+        }
+
+    def _get_trace_context(self) -> Dict[str, str]:
+        """
+        Gets the current tracing context if it exists.
+        """
+        span = trace.get_current_span()
+        if span.is_recording():
+            ctx = span.get_span_context()
+            return {
+                "trace_id": format(ctx.trace_id, "032x"),
+                "span_id": format(ctx.span_id, "016x")
+            }
+        return {}
+
+    def _log(
+            self,
+            level: int,
+            message: str,
+            *args,
+            **kwargs
+    ):
+        """
+        Create a structured log with tracing context.
+        """
+        extra = kwargs.pop("extra", {})
+        trace_context = self._get_trace_context()
+
+        additional_info = []
+        if kwargs.get("error_type"):
+            additional_info.append(f"type={kwargs['error_type']}")
+        if kwargs.get("error_message"):
+            additional_info.append(f"message={kwargs['error_message']}")
+        if kwargs.get("operation"):
+            additional_info.append(f"operation={kwargs['operation']}")
+
+        additional_str = f" - {', '.join(additional_info)}" if additional_info else ""
+        trace_str = f"[trace_id={trace_context.get('trace_id', '0')}]" if trace_context else ""
+
+        log_message = f"{trace_str} {message}{additional_str}"
+
+        self.logger.log(
+            level,
+            log_message,
+            extra={
+                "structured": True,
+                "trace_context": trace_context,
+                **extra,
+                **kwargs
+            }
+        )
+
+    def debug(self, message: str, *args, **kwargs):
+        self._log(logging.DEBUG, message, *args, **kwargs)
+
+    def info(self, message: str, *args, **kwargs):
+        self._log(logging.INFO, message, *args, **kwargs)
+
+    def error(self, message: str, *args, **kwargs):
+        self._log(logging.ERROR, message, *args, **kwargs)
+
+    @contextmanager
+    def operation_context(
+            self,
+            operation_name: str,
+            **context
+    ):
+        """
+        Provides context for an operation, recording its beginning and end.
+        """
+        try:
+            self.info(
+                f"Iniciando {operation_name}",
+                operation=operation_name,
+                status="started",
+                **context
+            )
+            yield
+            self.info(
+                f"Completado {operation_name}",
+                operation=operation_name,
+                status="completed",
+                **context
+            )
+        except Exception as e:
+            self.error(
+                f"Error en {operation_name}: {str(e)}",
+                operation=operation_name,
+                status="failed",
+                error=str(e),
+                **context
+            )
+            raise

otel_utils-0.1.11/src/otel_utils/metrics.py

@@ -0,0 +1,112 @@
+from contextlib import contextmanager
+from typing import Optional, Dict, Any, List
+from opentelemetry import metrics
+from opentelemetry.metrics import Observation, CallbackOptions
+import time
+
+
+class Metrics:
+    """
+    Advanced metrics utility that supports different types of measurements
+    and asynchronous callbacks.
+    """
+
+    def __init__(self, service_name: str):
+        self._meter = metrics.get_meter(service_name)
+        self._gauges = {}
+        self._histograms = {}
+        self._counters = {}
+
+    def create_histogram(
+            self,
+            name: str,
+            description: str = "",
+            unit: str = "1",
+            boundaries: List[float] = None
+    ):
+        """
+        Create a histogram with custom limits for distributions of values.
+        """
+        return self._meter.create_histogram(
+            name=name,
+            description=description,
+            unit=unit,
+            boundaries=boundaries
+        )
+
+    @contextmanager
+    def measure_duration(
+            self,
+            name: str,
+            attributes: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Measures the duration of a operation and records it as a histogram.
+        """
+        start_time = time.monotonic()
+        try:
+            yield
+        finally:
+            duration = time.monotonic() - start_time
+            self.get_histogram(name).record(
+                duration,
+                attributes=attributes
+            )
+
+    def observe_async(
+            self,
+            name: str,
+            description: str = "",
+            callback: callable = None
+    ):
+        """
+        Log metrics asynchronously using a callback.
+        Useful for metrics that need to be calculated or queried.
+        """
+        def observer_callback(options: CallbackOptions) -> List[Observation]:
+            """
+            Callback function for observable gauge metrics.
+
+            Args:
+                options: CallbackOptions object containing timing and context information
+                        for when the observation is being made. Though not used here,
+                        it's part of the OpenTelemetry interface and can be useful for:
+                        - Accessing timestamp of the observation
+                        - Getting the current context
+                        - Handling collection-specific parameters
+
+            Returns:
+                List[Observation]: A list containing the current observation value.
+                Returns [Observation(0)] in case of errors to maintain metric continuity.
+            """
+            try:
+                value = callback()
+                return [Observation(value)]
+            except Exception:
+                return [Observation(0)]
+
+        self._meter.create_observable_gauge(
+            name,
+            callbacks=[observer_callback],
+            description=description
+        )
+
+    def get_counter(self, name: str, description: str = "", unit: str = "1"):
+        """Gets or creates a counter."""
+        if name not in self._counters:
+            self._counters[name] = self._meter.create_counter(
+                name=name,
+                description=description,
+                unit=unit
+            )
+        return self._counters[name]
+
+    def get_histogram(self, name: str, description: str = "", unit: str = "1"):
+        """Gets or creates a histogram."""
+        if name not in self._histograms:
+            self._histograms[name] = self._meter.create_histogram(
+                name=name,
+                description=description,
+                unit=unit
+            )
+        return self._histograms[name]

otel_utils-0.1.11/src/otel_utils/tracing.py

@@ -0,0 +1,78 @@
+import functools
+from contextlib import contextmanager
+from typing import Optional, Iterator, Any, Dict
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode, Span, SpanKind
+
+
+class Tracer:
+    """
+    Advanced tracing utility that supports complex and nested traces.
+    """
+
+    def __init__(self, service_name: str):
+        self._tracer = trace.get_tracer(service_name)
+
+    @contextmanager
+    def start_as_current_span(
+            self,
+            name: str,
+            context: Optional[Any] = None,
+            kind: Optional[SpanKind] = SpanKind.INTERNAL,
+            attributes: Optional[Dict[str, Any]] = None,
+            links: Optional[list] = None
+    ) -> Iterator[Span]:
+        """
+        Creates a span and sets it as the current span in the context.
+        Properly handles the context propagation from external sources.
+        """
+        with self._tracer.start_as_current_span(
+                name,
+                context=context,
+                attributes=attributes,
+                kind=kind,
+                links=links
+        ) as span:
+            yield span
+
+    @contextmanager
+    def create_span(
+            self,
+            name: str,
+            attributes: Optional[Dict[str, Any]] = None,
+            kind: Optional[SpanKind] = SpanKind.INTERNAL,
+            links: Optional[list] = None
+    ) -> Iterator[Span]:
+        """
+        Creates a custom span that can be used in a 'with' context.
+        Useful for complex operations that need granular control.
+        """
+        with self._tracer.start_as_current_span(
+                name,
+                attributes=attributes,
+                kind=kind,
+                links=links
+        ) as span:
+            yield span
+
+    def trace(self, name: Optional[str] = None, attributes: Optional[Dict] = None):
+        def decorator(func):
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                with self._tracer.start_as_current_span(
+                        name or func.__name__,
+                        attributes=attributes,
+                        kind=SpanKind.SERVER
+                ) as span:
+                    try:
+                        result = await func(*args, **kwargs)
+                        span.set_status(Status(StatusCode.OK))
+                        return result
+                    except Exception as e:
+                        span.set_status(Status(StatusCode.ERROR), str(e))
+                        span.record_exception(e)
+                        raise
+
+            return async_wrapper
+
+        return decorator