Add metric on lock failure for IsManaged

Author: gleocadie

profiler/src/ProfilerEngine/Datadog.Profiler.Native/CorProfilerCallback.cpp

@@ -1567,7 +1567,7 @@ HRESULT STDMETHODCALLTYPE CorProfilerCallback::Initialize(IUnknown* corProfilerI
     // Use managed code cache
     if (_pConfiguration->UseManagedCodeCache())
     {
-        _managedCodeCache = std::make_unique<ManagedCodeCache>(_pCorProfilerInfo);
+        _managedCodeCache = std::make_unique<ManagedCodeCache>(_pCorProfilerInfo, _metricsRegistry);
         if (!_managedCodeCache->Initialize())
         {
             Log::Error("Failed to initialize managed code cache. The profiler will not run.");

profiler/src/ProfilerEngine/Datadog.Profiler.Native/ManagedCodeCache.cpp

@@ -4,6 +4,8 @@
 #include "ManagedCodeCache.h"
 
 #include "Configuration.h"
+#include "CounterMetric.h"
+#include "MetricsRegistry.h"
 
 #include <algorithm>
 #include <chrono>
@@ -88,8 +90,9 @@ struct IMAGE_NT_HEADERS_GENERIC
     WORD    Magic;
 };
 
-ManagedCodeCache::ManagedCodeCache(ICorProfilerInfo4* pProfilerInfo)
-    : _profilerInfo(pProfilerInfo)
+ManagedCodeCache::ManagedCodeCache(ICorProfilerInfo4* pProfilerInfo, MetricsRegistry& metricsRegistry)
+    : _profilerInfo(pProfilerInfo),
+      _lockFailureMetric(metricsRegistry.GetOrRegister<CounterMetric>("dotnet_managed_code_cache_lock_failures"))
 {
 }
 
@@ -239,7 +242,14 @@ std::optional<bool> ManagedCodeCache::IsManaged(std::uintptr_t ip) const noexcep
     // Best effort to identify an instruction pointer. When called from a signal
     // handler, IsManagedImpl uses a time-based lock acquire (bounded wait) and
     // returns std::nullopt if a lock cannot be acquired within the timeout.
-    return IsManagedImpl(ip);
+    auto result = IsManagedImpl(ip);
+    if (!result.has_value())
+    {
+        // Lock could not be acquired within the timeout: record it. Incr() is an
+        // atomic increment, so this is safe to call from a signal handler.
+        _lockFailureMetric->Incr();
+    }
+    return result;
 }
 
 std::optional<bool> ManagedCodeCache::IsManagedImpl(std::uintptr_t ip) const noexcept

profiler/src/ProfilerEngine/Datadog.Profiler.Native/ManagedCodeCache.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <atomic>
+#include <memory>
 #include <vector>
 #include <unordered_map>
 #include <unordered_set>
@@ -17,6 +18,9 @@
 #include "cor.h"
 #include "corprof.h"
 
+class CounterMetric;
+class MetricsRegistry;
+
 // Represents a single contiguous code range
 struct CodeRange {
     UINT_PTR startAddress;
@@ -73,7 +77,7 @@ class ManagedCodeCache {
 public:
     static constexpr FunctionID InvalidFunctionId = -1;
 
-    explicit ManagedCodeCache(ICorProfilerInfo4* pProfilerInfo);
+    ManagedCodeCache(ICorProfilerInfo4* pProfilerInfo, MetricsRegistry& metricsRegistry);
     ~ManagedCodeCache();
 
     // Signal-safe lookup methods (no allocation)
@@ -168,6 +172,10 @@ class ManagedCodeCache {
     // Profiler interface (ICorProfilerInfo4 is available in .NET Framework 4.5+)
     ICorProfilerInfo4* _profilerInfo;
 
+    // Counts how many times IsManaged failed to acquire a lock within the timeout
+    // (signal-handler read path backing off instead of blocking).
+    std::shared_ptr<CounterMetric> _lockFailureMetric;
+
     std::optional<FunctionID> GetFunctionIdImpl(std::uintptr_t ip) const noexcept;
     std::optional<bool> IsCodeInR2RModule(std::uintptr_t ip, bool signalSafe) const noexcept;
     std::optional<FunctionID> GetFunctionFromIP_Original(std::uintptr_t ip) noexcept;

profiler/test/Datadog.Profiler.Native.Tests/ManagedCodeCacheTest.cpp

@@ -4,6 +4,7 @@
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
 #include "ManagedCodeCache.h"
+#include "MetricsRegistry.h"
 #include "MockProfilerInfo.h"
 
 #include <thread>
@@ -15,11 +16,12 @@ using namespace testing;
 class ManagedCodeCacheTest : public Test {
 protected:
     MockProfilerInfo* mockProfiler;
+    MetricsRegistry metricsRegistry;
     std::unique_ptr<ManagedCodeCache> cache;
 
     void SetUp() override {
         mockProfiler = new MockProfilerInfo();
-        cache = std::make_unique<ManagedCodeCache>(mockProfiler);
+        cache = std::make_unique<ManagedCodeCache>(mockProfiler, metricsRegistry);
         cache->Initialize();
     }