fix(profiling): ensure RLock uses original allocate_lock (backport #4131) (#4135)

This is an automatic backport of pull request #4131 done by [Mergify](https://mergify.com).


---


<details>
<summary>Mergify commands and options</summary>

<br />

More conditions and actions can be found in the [documentation](https://docs.mergify.com/).

You can also trigger Mergify actions by commenting on this pull request:

- `@Mergifyio refresh` will re-evaluate the rules
- `@Mergifyio rebase` will rebase this PR on its base branch
- `@Mergifyio update` will merge the base branch into this PR
- `@Mergifyio backport <destination>` will backport this PR on `<destination>` branch

Additionally, on Mergify [dashboard](https://dashboard.mergify.com/) you can:

- look at your merge queues
- generate the Mergify configuration with the config editor.

Finally, you can contact us on https://mergify.com
</details>

Author: mergify[bot]

ddtrace/internal/nogevent.py

@@ -37,7 +37,43 @@ def is_module_patched(module):
 thread_get_ident = get_original(six.moves._thread.__name__, "get_ident")
 Thread = get_original("threading", "Thread")
 Lock = get_original("threading", "Lock")
-RLock = get_original("threading", "RLock")
+
+if six.PY2 and is_module_patched("threading"):
+    _allocate_lock = get_original("threading", "_allocate_lock")
+    _threading_RLock = get_original("threading", "_RLock")
+    _threading_Verbose = get_original("threading", "_Verbose")
+
+    class _RLock(_threading_RLock):
+        """Patched RLock to ensure threading._allocate_lock is called rather than
+        gevent.threading._allocate_lock if patching has occurred. This is not
+        necessary in Python 3 where the RLock function uses the _CRLock so is
+        unaffected by gevent patching.
+        """
+
+        def __init__(self, verbose=None):
+            # We want to avoid calling the RLock init as it will allocate a gevent lock
+            # That means we have to reproduce the code from threading._RLock.__init__ here
+            # https://github.com/python/cpython/blob/8d21aa21f2cbc6d50aab3f420bb23be1d081dac4/Lib/threading.py#L132-L136
+            _threading_Verbose.__init__(self, verbose)
+            self.__block = _allocate_lock()
+            self.__owner = None
+            self.__count = 0
+
+    def RLock(*args, **kwargs):
+        return _RLock(*args, **kwargs)
+
+
+else:
+    # We do not patch RLock in Python 3 however for < 3.7 the C implementation of
+    # RLock might not be available as the _thread module is optional.  In that
+    # case, the Python implementation will be used. This means there is still
+    # the possibility that RLock in Python 3 will cause problems for gevent with
+    # ddtrace profiling enabled though it remains an open question when that
+    # would be the case for the supported platforms.
+    # https://github.com/python/cpython/blob/c19983125a42a4b4958b11a26ab5e03752c956fc/Lib/threading.py#L38-L41
+    # https://github.com/python/cpython/blob/c19983125a42a4b4958b11a26ab5e03752c956fc/Doc/library/_thread.rst#L26-L27
+    RLock = get_original("threading", "RLock")
+
 
 is_threading_patched = is_module_patched("threading")
 

docs/spelling_wordlist.txt

@@ -149,6 +149,7 @@ runnable
 runtime
 runtimes
 runtime-id
+RLock
 sanic
 screenshots
 serializable

releasenotes/notes/nogevent-rlock-original-9e387eafb2be3d27.yaml

@@ -0,0 +1,4 @@
+---
+fixes:
+  - |
+    profiling: internal use of RLock needs to ensure original threading locks are used rather than gevent threading lock. Because of an indirection in the initialization of the original RLock, we end up getting an underlying gevent lock. We work around this behavior with gevent by creating a patched RLock for use internally.

tests/profiling/test_nogevent.py

@@ -0,0 +1,16 @@
+import os
+
+import pytest
+import six
+
+from ddtrace.internal import nogevent
+
+
+TESTING_GEVENT = os.getenv("DD_PROFILE_TEST_GEVENT", False)
+
+
+@pytest.mark.skipif(not TESTING_GEVENT or six.PY3, reason="Not testing gevent or testing on Python 3")
+def test_nogevent_rlock():
+    import gevent
+
+    assert not isinstance(nogevent.RLock()._RLock__block, gevent.thread.LockType)