chore(internal): add is_wrapped and is_wrapped_with helpers (#14295)

Useful helpers to ensure we can check if something is already wrapped to
avoid re-wrapping it, and we can check if it is already wrapped with a
specific function. Useful both for testing and patching.

## Checklist
- [x] PR author has checked that all the criteria below are met
- The PR description includes an overview of the change
- The PR description articulates the motivation for the change
- The change includes tests OR the PR description describes a testing
strategy
- The PR description notes risks associated with the change, if any
- Newly-added code is easy to change
- The change follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
- The change includes or references documentation updates if necessary
- Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist
- [ ] Reviewer has checked that all the criteria below are met 
- Title is accurate
- All changes are related to the pull request's stated goal
- Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes
- Testing strategy adequately addresses listed risks
- Newly-added code is easy to change
- Release note makes sense to a user of the library
- If necessary, author has acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment
- Backport labels are set in a manner that is consistent with the
[release branch maintenance
policy](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting)

Author: brettlangdon

ddtrace/internal/wrapping/__init__.py

@@ -269,6 +269,38 @@ def wrap(f, wrapper):
     return wf
 
 
+def is_wrapped(f: FunctionType) -> bool:
+    """Check if a function is wrapped with any wrapper."""
+    try:
+        wf = cast(WrappedFunction, f)
+        inner = cast(FunctionType, wf.__dd_wrapped__)
+
+        # Sanity check
+        assert inner.__name__ == "<wrapped>", "Wrapper has wrapped function"  # nosec
+        return True
+    except AttributeError:
+        return False
+
+
+def is_wrapped_with(f: FunctionType, wrapper: Wrapper) -> bool:
+    """Check if a function is wrapped with a specific wrapper."""
+    try:
+        wf = cast(WrappedFunction, f)
+        inner = cast(FunctionType, wf.__dd_wrapped__)
+
+        # Sanity check
+        assert inner.__name__ == "<wrapped>", "Wrapper has wrapped function"  # nosec
+
+        if wrapper in f.__code__.co_consts:
+            return True
+
+        # This is not the correct wrapping layer. Try with the next one.
+        return is_wrapped_with(inner, wrapper)
+
+    except AttributeError:
+        return False
+
+
 def unwrap(wf, wrapper):
     # type: (WrappedFunction, Wrapper) -> FunctionType
     """Unwrap a wrapped function.

tests/internal/test_wrapping.py

@@ -6,6 +6,8 @@
 
 import pytest
 
+from ddtrace.internal.wrapping import is_wrapped
+from ddtrace.internal.wrapping import is_wrapped_with
 from ddtrace.internal.wrapping import unwrap
 from ddtrace.internal.wrapping import wrap
 from ddtrace.internal.wrapping.context import WrappingContext
@@ -95,6 +97,71 @@ def f(a, b, c=None):
     assert not channel1 and not channel2
 
 
+def test_is_wrapped():
+    """Test that `is_wrapped` and `is_wrapped_with` work as expected."""
+
+    def first_wrapper(f, args, kwargs):
+        return f(*args, **kwargs)
+
+    def second_wrapper(f, args, kwargs):
+        return f(*args, **kwargs)
+
+    def f(a, b, c=None):
+        return (a, b, c)
+
+    # Function works
+    assert f(1, 2) == (1, 2, None)
+
+    # Not wrapped yet
+    assert not is_wrapped(f)
+    assert not is_wrapped_with(f, first_wrapper)
+    assert not is_wrapped_with(f, second_wrapper)
+
+    # Wrap with first wrapper
+    wrap(f, first_wrapper)
+
+    # Function still works
+    assert f(1, 2) == (1, 2, None)
+
+    # Only wrapped with first_wrapper
+    assert is_wrapped(f)
+    assert is_wrapped_with(f, first_wrapper)
+    assert not is_wrapped_with(f, second_wrapper)
+
+    # Wrap with second wrapper
+    wrap(f, second_wrapper)
+
+    # Function still works
+    assert f(1, 2) == (1, 2, None)
+
+    # Wrapped with everything
+    assert is_wrapped(f)
+    assert is_wrapped_with(f, first_wrapper)
+    assert is_wrapped_with(f, second_wrapper)
+
+    # Unwrap first wrapper
+    unwrap(f, first_wrapper)
+
+    # Function still works
+    assert f(1, 2) == (1, 2, None)
+
+    # Still wrapped with second_wrapper
+    assert is_wrapped(f)
+    assert not is_wrapped_with(f, first_wrapper)
+    assert is_wrapped_with(f, second_wrapper)
+
+    # Unwrap second wrapper
+    unwrap(f, second_wrapper)
+
+    # Function still works
+    assert f(1, 2) == (1, 2, None)
+
+    # Not wrapped anymore
+    assert not is_wrapped(f)
+    assert not is_wrapped_with(f, first_wrapper)
+    assert not is_wrapped_with(f, second_wrapper)
+
+
 @pytest.mark.skipif(sys.version_info > (3, 12), reason="segfault on 3.13")
 def test_wrap_generator():
     channel = []