chore(profiling): remove '_self_' prefixes from attributes following unwrapt in Lock Profiler code

Author: vlad-scherbich

ddtrace/profiling/collector/_lock.py

@@ -40,13 +40,13 @@ class _ProfiledLock:
 
     __slots__ = (
         "__wrapped__",
-        "_self_tracer",
-        "_self_max_nframes",
-        "_self_capture_sampler",
-        "_self_endpoint_collection_enabled",
-        "_self_init_loc",
-        "_self_acquired_at",
-        "_self_name",
+        "tracer",
+        "max_nframes",
+        "capture_sampler",
+        "endpoint_collection_enabled",
+        "init_location",
+        "acquired_time",
+        "name",
     )
 
     def __init__(
@@ -58,16 +58,16 @@ def __init__(
         endpoint_collection_enabled: bool,
     ) -> None:
         self.__wrapped__: Any = wrapped
-        self._self_tracer: Optional[Tracer] = tracer
-        self._self_max_nframes: int = max_nframes
-        self._self_capture_sampler: collector.CaptureSampler = capture_sampler
-        self._self_endpoint_collection_enabled: bool = endpoint_collection_enabled
+        self.tracer: Optional[Tracer] = tracer
+        self.max_nframes: int = max_nframes
+        self.capture_sampler: collector.CaptureSampler = capture_sampler
+        self.endpoint_collection_enabled: bool = endpoint_collection_enabled
         # Frame depth: 0=__init__, 1=_profiled_allocate_lock, 2=_LockAllocatorWrapper.__call__, 3=caller
         frame: FrameType = sys._getframe(3)
         code: CodeType = frame.f_code
-        self._self_init_loc: str = "%s:%d" % (os.path.basename(code.co_filename), frame.f_lineno)
-        self._self_acquired_at: int = 0
-        self._self_name: Optional[str] = None
+        self.init_location: str = f"{os.path.basename(code.co_filename)}:{frame.f_lineno}"
+        self.acquired_time: int = 0
+        self.name: Optional[str] = None
 
     def __aenter__(self, *args: Any, **kwargs: Any) -> Any:
         return self._acquire(self.__wrapped__.__aenter__, *args, **kwargs)
@@ -76,7 +76,7 @@ def __aexit__(self, *args: Any, **kwargs: Any) -> Any:
         return self._release(self.__wrapped__.__aexit__, *args, **kwargs)
 
     def _acquire(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
-        if not self._self_capture_sampler.capture():
+        if not self.capture_sampler.capture():
             return inner_func(*args, **kwargs)
 
         start: int = time.monotonic_ns()
@@ -85,7 +85,7 @@ def _acquire(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
         finally:
             try:
                 end: int = time.monotonic_ns()
-                self._self_acquired_at = end
+                self.acquired_time = end
 
                 thread_id: int
                 thread_name: str
@@ -96,10 +96,8 @@ def _acquire(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
                 task_frame: Optional[FrameType]
                 task_id, task_name, task_frame = _task.get_task(thread_id)
 
-                self._maybe_update_self_name()
-                lock_name: str = (
-                    "%s:%s" % (self._self_init_loc, self._self_name) if self._self_name else self._self_init_loc
-                )
+                self._update_name()
+                lock_name: str = "%s:%s" % (self.init_location, self.name) if self.name else self.init_location
 
                 frame: FrameType
                 if task_frame is None:
@@ -110,7 +108,7 @@ def _acquire(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
                     frame = task_frame
 
                 frames: List[DDFrame]
-                frames, _ = _traceback.pyframe_to_frames(frame, self._self_max_nframes)
+                frames, _ = _traceback.pyframe_to_frames(frame, self.max_nframes)
 
                 thread_native_id: int = _threading.get_thread_native_id(thread_id)
 
@@ -122,8 +120,8 @@ def _acquire(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
                 handle.push_task_id(task_id)
                 handle.push_task_name(task_name)
 
-                if self._self_tracer is not None:
-                    handle.push_span(self._self_tracer.current_span())
+                if self.tracer is not None:
+                    handle.push_span(self.tracer.current_span())
                 for ddframe in frames:
                     handle.push_frame(ddframe.function_name, ddframe.file_name, 0, ddframe.lineno)
                 handle.flush_sample()
@@ -134,15 +132,15 @@ def acquire(self, *args: Any, **kwargs: Any) -> Any:
         return self._acquire(self.__wrapped__.acquire, *args, **kwargs)
 
     def _release(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) -> None:
-        start: Optional[int] = getattr(self, "_self_acquired_at", None)
+        start: Optional[int] = getattr(self, "acquired_time", None)
         try:
             # Though it should generally be avoided to call release() from
             # multiple threads, it is possible to do so. In that scenario, the
             # following statement code will raise an AttributeError. This should
             # not be propagated to the caller and to the users. The inner_func
             # will raise an RuntimeError as the threads are trying to release()
             # and unlocked lock, and the expected behavior is to propagate that.
-            del self._self_acquired_at
+            del self.acquired_time
         except AttributeError:
             # We just ignore the error, if the attribute is not found.
             pass
@@ -161,9 +159,7 @@ def _release(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
                 task_frame: Optional[FrameType]
                 task_id, task_name, task_frame = _task.get_task(thread_id)
 
-                lock_name: str = (
-                    "%s:%s" % (self._self_init_loc, self._self_name) if self._self_name else self._self_init_loc
-                )
+                lock_name: str = "%s:%s" % (self.init_location, self.name) if self.name else self.init_location
 
                 frame: FrameType
                 if task_frame is None:
@@ -173,7 +169,7 @@ def _release(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
                     frame = task_frame
 
                 frames: List[DDFrame]
-                frames, _ = _traceback.pyframe_to_frames(frame, self._self_max_nframes)
+                frames, _ = _traceback.pyframe_to_frames(frame, self.max_nframes)
 
                 thread_native_id: int = _threading.get_thread_native_id(thread_id)
 
@@ -185,8 +181,8 @@ def _release(self, inner_func: Callable[..., Any], *args: Any, **kwargs: Any) ->
                 handle.push_task_id(task_id)
                 handle.push_task_name(task_name)
 
-                if self._self_tracer is not None:
-                    handle.push_span(self._self_tracer.current_span())
+                if self.tracer is not None:
+                    handle.push_span(self.tracer.current_span())
                 for ddframe in frames:
                     handle.push_frame(ddframe.function_name, ddframe.file_name, 0, ddframe.lineno)
                 handle.flush_sample()
@@ -200,7 +196,7 @@ def __enter__(self, *args: Any, **kwargs: Any) -> Any:
     def __exit__(self, *args: Any, **kwargs: Any) -> None:
         self._release(self.__wrapped__.__exit__, *args, **kwargs)
 
-    def _find_self_name(self, var_dict: Dict[str, Any]) -> Optional[str]:
+    def _find_name(self, var_dict: Dict[str, Any]) -> Optional[str]:
         for name, value in var_dict.items():
             if name.startswith("__") or isinstance(value, ModuleType):
                 continue
@@ -210,7 +206,6 @@ def _find_self_name(self, var_dict: Dict[str, Any]) -> Optional[str]:
                 for attribute in dir(value):
                     try:
                         if not attribute.startswith("__") and getattr(value, attribute) is self:
-                            self._self_name = attribute
                             return attribute
                     except AttributeError:
                         # Accessing unset attributes in __slots__ raises AttributeError.
@@ -219,8 +214,8 @@ def _find_self_name(self, var_dict: Dict[str, Any]) -> Optional[str]:
 
     # Get lock acquire/release call location and variable name the lock is assigned to
     # This function propagates ValueError if the frame depth is <= 3.
-    def _maybe_update_self_name(self) -> None:
-        if self._self_name is not None:
+    def _update_name(self) -> None:
+        if self.name is not None:
             return
         # We expect the call stack to be like this:
         # 0: this
@@ -245,17 +240,17 @@ def _maybe_update_self_name(self) -> None:
         frame = sys._getframe(3)
 
         # First, look at the local variables of the caller frame, and then the global variables
-        self._self_name = self._find_self_name(frame.f_locals) or self._find_self_name(frame.f_globals)
+        self.name = self._find_name(frame.f_locals) or self._find_name(frame.f_globals)
 
-        if not self._self_name:
-            self._self_name = ""
+        if not self.name:
+            self.name = ""
 
     def locked(self) -> bool:
         """Return True if lock is currently held."""
         return self.__wrapped__.locked()
 
     def __repr__(self) -> str:
-        return f"<_ProfiledLock({self.__wrapped__!r}) at {self._self_init_loc}>"
+        return f"<_ProfiledLock({self.__wrapped__!r}) at {self.init_location}>"
 
     def __bool__(self) -> bool:
         """For use in with statements."""

tests/profiling_v2/collector/test_threading.py

@@ -97,11 +97,7 @@ def test_patch():
     lock = threading.Lock
     collector = ThreadingLockCollector()
     collector.start()
-<<<<<<< HEAD
     assert lock == collector._original_lock
-=======
-    assert lock == collector._original
->>>>>>> 2577e6d3a6 (Remove 'wrapt' dependency from the Lock Profiler)
     # After patching, threading.Lock is replaced with our wrapper
     # The old reference (lock) points to the original builtin Lock class
     assert lock != threading.Lock  # They're different after patching
@@ -110,11 +106,7 @@ def test_patch():
     collector.stop()
     # After stopping, everything is restored
     assert lock == threading.Lock
-<<<<<<< HEAD
     assert collector._original_lock == threading.Lock
-=======
-    assert collector._original == threading.Lock
->>>>>>> 2577e6d3a6 (Remove 'wrapt' dependency from the Lock Profiler)
 
 
 @pytest.mark.skipif(not sys.platform.startswith("linux"), reason="only works on linux")