Function wrapper

agentops/sdk/decorators/factory.py:101–482

(
            wrapped_func: Callable[..., Any], instance: Optional[Any], args: tuple, kwargs: Dict[str, Any]
        )

        @wrapt.decorator
        def wrapper(
            wrapped_func: Callable[..., Any], instance: Optional[Any], args: tuple, kwargs: Dict[str, Any]
        ) -> Any:
            if not tracer.initialized:
                return wrapped_func(*args, **kwargs)

            operation_name = name or wrapped_func.__name__
            is_async = asyncio.iscoroutinefunction(wrapped_func)
            is_generator = inspect.isgeneratorfunction(wrapped_func)
            is_async_generator = inspect.isasyncgenfunction(wrapped_func)

            # Special handling for HTTP entity kind
            if entity_kind == SpanKind.HTTP:
                if is_generator or is_async_generator:
                    logger.warning(
                        f"@track_endpoint on generator '{operation_name}' is not supported. Use @trace instead."
                    )
                    return wrapped_func(*args, **kwargs)

                if is_async:

                    async def _wrapped_http_async() -> Any:
                        trace_context: Optional[TraceContext] = None
                        try:
                            # Create main session span
                            trace_context = tracer.start_trace(trace_name=operation_name, tags=tags)
                            if not trace_context:
                                logger.error(
                                    f"Failed to start trace for @track_endpoint '{operation_name}'. Executing without trace."
                                )
                                return await wrapped_func(*args, **kwargs)

                            # Create HTTP request span
                            if capture_request:
                                with _create_as_current_span(
                                    f"{operation_name}.request",
                                    SpanKind.HTTP,
                                    version=version,
                                    attributes={SpanAttributes.HTTP_METHOD: "REQUEST"}
                                    if SpanAttributes.HTTP_METHOD
                                    else None,
                                ) as request_span:
                                    try:
                                        request_data = _extract_request_data()
                                        if request_data:
                                            # Set HTTP attributes
                                            if hasattr(SpanAttributes, "HTTP_METHOD") and request_data.get("method"):
                                                request_span.set_attribute(
                                                    SpanAttributes.HTTP_METHOD, request_data["method"]
                                                )
                                            if hasattr(SpanAttributes, "HTTP_URL") and request_data.get("url"):
                                                request_span.set_attribute(SpanAttributes.HTTP_URL, request_data["url"])

                                            # Record the full request data
                                            _record_entity_input(request_span, (request_data,), {})
                                    except Exception as e:
                                        logger.warning(f"Failed to record HTTP request for '{operation_name}': {e}")