lmnr 0.6.21__py3-none-any.whl → 0.7.0__py3-none-any.whl

lmnr/__init__.py

@@ -9,7 +9,6 @@ from .sdk.types import (
     HumanEvaluator,
     RunAgentResponseChunk,
     StepChunkContent,
-    TracingLevel,
 )
 from .sdk.decorators import observe
 from .sdk.types import LaminarSpanContext
@@ -18,7 +17,6 @@ from .opentelemetry_lib.tracing.attributes import Attributes
 from .opentelemetry_lib.tracing.instruments import Instruments
 from .opentelemetry_lib.tracing.processor import LaminarSpanProcessor
 from .opentelemetry_lib.tracing.tracer import get_laminar_tracer_provider, get_tracer
-from opentelemetry.trace import use_span
 
 __all__ = [
     "AgentOutput",
@@ -36,10 +34,8 @@ __all__ = [
     "LaminarSpanProcessor",
     "RunAgentResponseChunk",
     "StepChunkContent",
-    "TracingLevel",
     "get_laminar_tracer_provider",
     "get_tracer",
     "evaluate",
     "observe",
-    "use_span",
 ]

lmnr/opentelemetry_lib/decorators/__init__.py

@@ -5,13 +5,12 @@ import orjson
 import types
 from typing import Any, AsyncGenerator, Callable, Generator, Literal
 
-from opentelemetry import trace
 from opentelemetry import context as context_api
 from opentelemetry.trace import Span
 
 from lmnr.sdk.utils import get_input_from_func_args, is_method
 from lmnr.opentelemetry_lib import MAX_MANUAL_SPAN_PAYLOAD_SIZE
-from lmnr.opentelemetry_lib.tracing.tracer import get_tracer
+from lmnr.opentelemetry_lib.tracing.tracer import get_tracer_with_context
 from lmnr.opentelemetry_lib.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     SPAN_INPUT,
@@ -37,6 +36,7 @@ def default_json(o):
     try:
         return str(o)
     except Exception:
+        logger.debug("Failed to serialize data to JSON, inner type: %s", type(o))
         pass
     return DEFAULT_PLACEHOLDER
 
@@ -61,8 +61,13 @@ def _setup_span(
     span_name: str, span_type: str, association_properties: dict[str, Any] | None
 ):
     """Set up a span with the given name, type, and association properties."""
-    with get_tracer() as tracer:
-        span = tracer.start_span(span_name, attributes={SPAN_TYPE: span_type})
+    with get_tracer_with_context() as (tracer, isolated_context):
+        # Create span in isolated context
+        span = tracer.start_span(
+            span_name,
+            context=isolated_context,
+            attributes={SPAN_TYPE: span_type},
+        )
 
         if association_properties is not None:
             for key, value in association_properties.items():
@@ -148,10 +153,10 @@ def _process_output(
         pass
 
 
-def _cleanup_span(span: Span, ctx_token):
+def _cleanup_span(span: Span, wrapper: TracerWrapper):
     """Clean up span and context."""
     span.end()
-    context_api.detach(ctx_token)
+    wrapper.pop_span_context()
 
 
 def observe_base(
@@ -171,10 +176,11 @@ def observe_base(
                 return fn(*args, **kwargs)
 
             span_name = name or fn.__name__
+            wrapper = TracerWrapper()
 
             span = _setup_span(span_name, span_type, association_properties)
-            ctx = trace.set_span_in_context(span, context_api.get_current())
-            ctx_token = context_api.attach(ctx)
+            new_context = wrapper.push_span_context(span)
+            ctx_token = context_api.attach(new_context)
 
             _process_input(
                 span, fn, args, kwargs, ignore_input, ignore_inputs, input_formatter
@@ -184,8 +190,11 @@ def observe_base(
                 res = fn(*args, **kwargs)
             except Exception as e:
                 _process_exception(span, e)
-                _cleanup_span(span, ctx_token)
+                _cleanup_span(span, wrapper)
                 raise e
+            finally:
+                # Always restore global context
+                context_api.detach(ctx_token)
 
             # span will be ended in the generator
             if isinstance(res, types.GeneratorType):
@@ -201,7 +210,7 @@ def observe_base(
                 return _ahandle_generator(span, ctx_token, res)
 
             _process_output(span, res, ignore_output, output_formatter)
-            _cleanup_span(span, ctx_token)
+            _cleanup_span(span, wrapper)
             return res
 
         return wrap
@@ -227,10 +236,11 @@ def async_observe_base(
                 return await fn(*args, **kwargs)
 
             span_name = name or fn.__name__
+            wrapper = TracerWrapper()
 
             span = _setup_span(span_name, span_type, association_properties)
-            ctx = trace.set_span_in_context(span, context_api.get_current())
-            ctx_token = context_api.attach(ctx)
+            new_context = wrapper.push_span_context(span)
+            ctx_token = context_api.attach(new_context)
 
             _process_input(
                 span, fn, args, kwargs, ignore_input, ignore_inputs, input_formatter
@@ -240,8 +250,11 @@ def async_observe_base(
                 res = await fn(*args, **kwargs)
             except Exception as e:
                 _process_exception(span, e)
-                _cleanup_span(span, ctx_token)
+                _cleanup_span(span, wrapper)
                 raise e
+            finally:
+                # Always restore global context
+                context_api.detach(ctx_token)
 
             # span will be ended in the generator
             if isinstance(res, types.AsyncGeneratorType):
@@ -250,7 +263,7 @@ def async_observe_base(
                 return await _ahandle_generator(span, ctx_token, res)
 
             _process_output(span, res, ignore_output, output_formatter)
-            _cleanup_span(span, ctx_token)
+            _cleanup_span(span, wrapper)
             return res
 
         return wrap
@@ -258,22 +271,19 @@ def async_observe_base(
     return decorate
 
 
-def _handle_generator(span: Span, ctx_token, res: Generator[Any, Any, Any]):
-    yield from res
-
-    span.end()
-    if ctx_token is not None:
-        context_api.detach(ctx_token)
-
+def _handle_generator(span: Span, wrapper: TracerWrapper, res: Generator):
+    try:
+        yield from res
+    finally:
+        _cleanup_span(span, wrapper)
 
-async def _ahandle_generator(span: Span, ctx_token, res: AsyncGenerator[Any, Any]):
-    # async with contextlib.aclosing(res) as closing_gen:
-    async for part in res:
-        yield part
 
-    span.end()
-    if ctx_token is not None:
-        context_api.detach(ctx_token)
+async def _ahandle_generator(span: Span, wrapper: TracerWrapper, res: AsyncGenerator):
+    try:
+        async for part in res:
+            yield part
+    finally:
+        _cleanup_span(span, wrapper)
 
 
 def _process_exception(span: Span, e: Exception):

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/__init__.py

@@ -30,6 +30,8 @@ from .utils import (
     should_emit_events,
 )
 from .version import __version__
+
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
 from opentelemetry.metrics import Counter, Histogram, Meter, get_meter
@@ -396,9 +398,10 @@ def _wrap(
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "Anthropic",
+            SpanAttributes.LLM_SYSTEM: "anthropic",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
+        context=get_current_context(),
     )
 
     _handle_input(span, event_logger, kwargs)
@@ -493,9 +496,10 @@ async def _awrap(
         name,
         kind=SpanKind.CLIENT,
         attributes={
-            SpanAttributes.LLM_SYSTEM: "Anthropic",
+            SpanAttributes.LLM_SYSTEM: "anthropic",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
+        context=get_current_context(),
     )
     await _ahandle_input(span, event_logger, kwargs)
 

lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/__init__.py

@@ -8,6 +8,8 @@ from typing import AsyncGenerator, Callable, Collection, Generator
 
 from google.genai import types
 
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
+
 from .config import (
     Config,
 )
@@ -474,6 +476,7 @@ def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
             SpanAttributes.LLM_SYSTEM: "gemini",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
+        context=get_current_context(),
     )
 
     if span.is_recording():
@@ -509,6 +512,7 @@ async def _awrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
             SpanAttributes.LLM_SYSTEM: "gemini",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
+        context=get_current_context(),
     )
 
     if span.is_recording():

lmnr/opentelemetry_lib/opentelemetry/instrumentation/groq/__init__.py

@@ -27,6 +27,7 @@ from .utils import (
     should_emit_events,
 )
 from .version import __version__
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
 from opentelemetry.metrics import Counter, Histogram, Meter, get_meter
@@ -245,6 +246,7 @@ def _wrap(
             SpanAttributes.LLM_SYSTEM: "Groq",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
+        context=get_current_context(),
     )
 
     _handle_input(span, kwargs, event_logger)
@@ -327,6 +329,7 @@ async def _awrap(
             SpanAttributes.LLM_SYSTEM: "Groq",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },
+        context=get_current_context(),
     )
 
     _handle_input(span, kwargs, event_logger)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py

@@ -12,10 +12,7 @@ from langchain_core.runnables.graph import Graph
 from opentelemetry.trace import Tracer
 from wrapt import wrap_function_wrapper
 from opentelemetry.trace import get_tracer
-
-from lmnr.opentelemetry_lib.tracing.context_properties import (
-    update_association_properties,
-)
+from opentelemetry.context import get_value, attach, set_value
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import unwrap
@@ -45,12 +42,13 @@ def wrap_pregel_stream(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs)
         }
         for edge in graph.edges
     ]
-    update_association_properties(
-        {
-            "langgraph.edges": json.dumps(edges),
-            "langgraph.nodes": json.dumps(nodes),
-        },
-    )
+    d = {
+        "langgraph.edges": json.dumps(edges),
+        "langgraph.nodes": json.dumps(nodes),
+    }
+    association_properties = get_value("lmnr.langgraph.graph") or {}
+    association_properties.update(d)
+    attach(set_value("lmnr.langgraph.graph", association_properties))
     return wrapped(*args, **kwargs)
 
 
@@ -75,12 +73,14 @@ async def async_wrap_pregel_stream(
         }
         for edge in graph.edges
     ]
-    update_association_properties(
-        {
-            "langgraph.edges": json.dumps(edges),
-            "langgraph.nodes": json.dumps(nodes),
-        },
-    )
+
+    d = {
+        "langgraph.edges": json.dumps(edges),
+        "langgraph.nodes": json.dumps(nodes),
+    }
+    association_properties = get_value("lmnr.langgraph.graph") or {}
+    association_properties.update(d)
+    attach(set_value("lmnr.langgraph.graph", association_properties))
 
     async for item in wrapped(*args, **kwargs):
         yield item

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/chat_wrappers.py

@@ -39,6 +39,7 @@ from ..utils import (
     should_emit_events,
     should_send_prompts,
 )
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.metrics import Counter, Histogram
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
@@ -87,6 +88,7 @@ def chat_wrapper(
         SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     run_async(_handle_request(span, kwargs, instance))
@@ -184,6 +186,7 @@ async def achat_wrapper(
         SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     await _handle_request(span, kwargs, instance)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/shared/completion_wrappers.py

@@ -27,6 +27,7 @@ from ..utils import (
     should_emit_events,
     should_send_prompts,
 )
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv_ai import (
@@ -55,6 +56,7 @@ def completion_wrapper(tracer, wrapped, instance, args, kwargs):
         SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     _handle_request(span, kwargs, instance)
@@ -89,6 +91,7 @@ async def acompletion_wrapper(tracer, wrapped, instance, args, kwargs):
         name=SPAN_NAME,
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value},
+        context=get_current_context(),
     )
 
     _handle_request(span, kwargs, instance)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py

@@ -17,6 +17,7 @@ from ..utils import (
     dont_throw,
     should_emit_events,
 )
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv_ai import LLMRequestTypeValues, SpanAttributes
@@ -126,6 +127,7 @@ def messages_list_wrapper(tracer, wrapped, instance, args, kwargs):
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
         start_time=run.get("start_time"),
+        context=get_current_context(),
     )
 
     if exception := run.get("exception"):
@@ -250,6 +252,7 @@ def runs_create_and_stream_wrapper(tracer, wrapped, instance, args, kwargs):
         "openai.assistant.run_stream",
         kind=SpanKind.CLIENT,
         attributes={SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value},
+        context=get_current_context(),
     )
 
     i = 0

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/v1/responses_wrappers.py

@@ -36,6 +36,7 @@ except ImportError:
     ResponseOutputMessageParam = Dict[str, Any]
     RESPONSES_AVAILABLE = False
 
+from lmnr.opentelemetry_lib.tracing.context import get_current_context
 from openai._legacy_response import LegacyAPIResponse
 from opentelemetry import context as context_api
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
@@ -429,6 +430,7 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
             start_time=(
                 start_time if traced_data is None else int(traced_data.start_time)
             ),
+            context=get_current_context(),
         )
         span.set_attribute(ERROR_TYPE, e.__class__.__name__)
         span.record_exception(e)
@@ -472,6 +474,7 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=int(traced_data.start_time),
+            context=get_current_context(),
         )
         set_data_attributes(traced_data, span)
         span.end()
@@ -523,6 +526,7 @@ async def async_responses_get_or_create_wrapper(
             start_time=(
                 start_time if traced_data is None else int(traced_data.start_time)
             ),
+            context=get_current_context(),
         )
         span.set_attribute(ERROR_TYPE, e.__class__.__name__)
         span.record_exception(e)
@@ -566,6 +570,7 @@ async def async_responses_get_or_create_wrapper(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=int(traced_data.start_time),
+            context=get_current_context(),
         )
         set_data_attributes(traced_data, span)
         span.end()
@@ -590,6 +595,7 @@ def responses_cancel_wrapper(tracer: Tracer, wrapped, instance, args, kwargs):
             kind=SpanKind.CLIENT,
             start_time=existing_data.start_time,
             record_exception=True,
+            context=get_current_context(),
         )
         span.record_exception(Exception("Response cancelled"))
         set_data_attributes(existing_data, span)
@@ -616,6 +622,7 @@ async def async_responses_cancel_wrapper(
             kind=SpanKind.CLIENT,
             start_time=existing_data.start_time,
             record_exception=True,
+            context=get_current_context(),
         )
         span.record_exception(Exception("Response cancelled"))
         set_data_attributes(existing_data, span)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/threading/__init__.py

@@ -0,0 +1,190 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Instrument threading to propagate OpenTelemetry context.
+
+Copied from opentelemetry-instrumentation-threading at commit:
+ad2fe813abb2ab0b6e25bedeebef5041ca3189f7
+https://github.com/open-telemetry/opentelemetry-python-contrib/blob/ad2fe813abb2ab0b6e25bedeebef5041ca3189f7/instrumentation/opentelemetry-instrumentation-threading/src/opentelemetry/instrumentation/threading/__init__.py
+
+Modified to use the Laminar isolated context.
+
+Usage
+-----
+
+.. code-block:: python
+
+    from opentelemetry.instrumentation.threading import ThreadingInstrumentor
+
+    ThreadingInstrumentor().instrument()
+
+This library provides instrumentation for the `threading` module to ensure that
+the OpenTelemetry context is propagated across threads. It is important to note
+that this instrumentation does not produce any telemetry data on its own. It
+merely ensures that the context is correctly propagated when threads are used.
+
+
+When instrumented, new threads created using threading.Thread, threading.Timer,
+or within futures.ThreadPoolExecutor will have the current OpenTelemetry
+context attached, and this context will be re-activated in the thread's
+run method or the executor's worker thread."
+"""
+
+from __future__ import annotations
+
+import threading
+from concurrent import futures
+from typing import TYPE_CHECKING, Any, Callable, Collection
+
+from wrapt import (
+    wrap_function_wrapper,  # type: ignore[reportUnknownVariableType]
+)
+
+from lmnr.opentelemetry_lib.tracing.context import (
+    get_current_context,
+    attach_context,
+    detach_context,
+)
+from opentelemetry import context
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+
+_instruments = ()
+
+if TYPE_CHECKING:
+    from typing import Protocol, TypeVar
+
+    R = TypeVar("R")
+
+    class HasOtelContext(Protocol):
+        _otel_context: context.Context
+
+
+class ThreadingInstrumentor(BaseInstrumentor):
+    __WRAPPER_START_METHOD = "start"
+    __WRAPPER_RUN_METHOD = "run"
+    __WRAPPER_SUBMIT_METHOD = "submit"
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs: Any):
+        self._instrument_thread()
+        self._instrument_timer()
+        self._instrument_thread_pool()
+
+    def _uninstrument(self, **kwargs: Any):
+        self._uninstrument_thread()
+        self._uninstrument_timer()
+        self._uninstrument_thread_pool()
+
+    @staticmethod
+    def _instrument_thread():
+        wrap_function_wrapper(
+            threading.Thread,
+            ThreadingInstrumentor.__WRAPPER_START_METHOD,
+            ThreadingInstrumentor.__wrap_threading_start,
+        )
+        wrap_function_wrapper(
+            threading.Thread,
+            ThreadingInstrumentor.__WRAPPER_RUN_METHOD,
+            ThreadingInstrumentor.__wrap_threading_run,
+        )
+
+    @staticmethod
+    def _instrument_timer():
+        wrap_function_wrapper(
+            threading.Timer,
+            ThreadingInstrumentor.__WRAPPER_START_METHOD,
+            ThreadingInstrumentor.__wrap_threading_start,
+        )
+        wrap_function_wrapper(
+            threading.Timer,
+            ThreadingInstrumentor.__WRAPPER_RUN_METHOD,
+            ThreadingInstrumentor.__wrap_threading_run,
+        )
+
+    @staticmethod
+    def _instrument_thread_pool():
+        wrap_function_wrapper(
+            futures.ThreadPoolExecutor,
+            ThreadingInstrumentor.__WRAPPER_SUBMIT_METHOD,
+            ThreadingInstrumentor.__wrap_thread_pool_submit,
+        )
+
+    @staticmethod
+    def _uninstrument_thread():
+        unwrap(threading.Thread, ThreadingInstrumentor.__WRAPPER_START_METHOD)
+        unwrap(threading.Thread, ThreadingInstrumentor.__WRAPPER_RUN_METHOD)
+
+    @staticmethod
+    def _uninstrument_timer():
+        unwrap(threading.Timer, ThreadingInstrumentor.__WRAPPER_START_METHOD)
+        unwrap(threading.Timer, ThreadingInstrumentor.__WRAPPER_RUN_METHOD)
+
+    @staticmethod
+    def _uninstrument_thread_pool():
+        unwrap(
+            futures.ThreadPoolExecutor,
+            ThreadingInstrumentor.__WRAPPER_SUBMIT_METHOD,
+        )
+
+    @staticmethod
+    def __wrap_threading_start(
+        call_wrapped: Callable[[], None],
+        instance: HasOtelContext,
+        args: tuple[()],
+        kwargs: dict[str, Any],
+    ) -> None:
+        instance._otel_context = get_current_context()
+        return call_wrapped(*args, **kwargs)
+
+    @staticmethod
+    def __wrap_threading_run(
+        call_wrapped: Callable[..., R],
+        instance: HasOtelContext,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> R:
+        token = None
+        try:
+            token = attach_context(instance._otel_context)
+            return call_wrapped(*args, **kwargs)
+        finally:
+            if token is not None:
+                detach_context(token)
+
+    @staticmethod
+    def __wrap_thread_pool_submit(
+        call_wrapped: Callable[..., R],
+        instance: futures.ThreadPoolExecutor,
+        args: tuple[Callable[..., Any], ...],
+        kwargs: dict[str, Any],
+    ) -> R:
+        # obtain the original function and wrapped kwargs
+        original_func = args[0]
+        otel_context = get_current_context()
+
+        def wrapped_func(*func_args: Any, **func_kwargs: Any) -> R:
+            token = None
+            try:
+                token = attach_context(otel_context)
+                return original_func(*func_args, **func_kwargs)
+            finally:
+                if token is not None:
+                    detach_context(token)
+
+        # replace the original function with the wrapped function
+        new_args: tuple[Callable[..., Any], ...] = (wrapped_func,) + args[1:]
+        return call_wrapped(*new_args, **kwargs)