[Profiler] Allow lock contention provider to upscale by duration instead of by count (#4263)

* Allow lock contention provider to upscale by value instead of by count
* Raw lock contention count/duration labels are sent as numeric label for timeline

Author: chrisnas

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

@@ -81,7 +81,7 @@ void ContentionProvider::OnContention(double contentionDurationNs)
     {
         std::lock_guard lock(_contentionsLock);
 
-        if (!_sampler.Sample(bucket))
+        if (!_sampler.Sample(bucket, static_cast<uint64_t>(contentionDurationNs)))
         {
             return;
         }

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

@@ -16,6 +16,8 @@ struct UpscaleGroupInfo
     TGroup Group;
     uint64_t RealCount;
     uint64_t SampledCount;
+    uint64_t RealValue;
+    uint64_t SampledValue;
 };
 
 // Template class that support "sampling by group".
@@ -34,24 +36,27 @@ class GroupSampler : public GenericSampler
 public:
     struct GroupInfo
     {
-        uint64_t Real;
-        uint64_t Sampled;
+        uint64_t RealCount;
+        uint64_t SampledCount;
+        uint64_t RealValue;
+        uint64_t SampledValue;
     };
 
 public:
-    bool Sample(TGroup group)
+    bool Sample(TGroup group, uint64_t value = 0)
     {
         std::unique_lock lock(_groupsMutex);
 
-        // increment the real count for the given group
+        // increment the real count and value for the given group
         GroupInfo* pInfo;
-        AddInGroup(group, pInfo);
+        AddInGroup(group, pInfo, value);
 
         auto [it, inserted] = _knownGroups.insert(std::move(group));
         if (inserted && _keepAtLeastOne)
         {
-            // increment the sampled count for the given group
-            pInfo->Sampled++;
+            // increment the sampled count and value for the given group
+            pInfo->SampledCount++;
+            pInfo->SampledValue += value;
 
             // This is the first time we see this group in this time window,
             // so force the sampling decision
@@ -61,29 +66,32 @@ class GroupSampler : public GenericSampler
         auto sampled = _sampler.Sample();
         if (sampled)
         {
-            // increment the sampled count for the given group
-            pInfo->Sampled++;
+            // increment the sampled count and value for the given group
+            pInfo->SampledCount++;
+            pInfo->SampledValue += value;
         }
 
         return sampled;
     }
 
     // MUST be called under the lock
-    void AddInGroup(TGroup group, GroupInfo*& groupInfo)
+    void AddInGroup(TGroup group, GroupInfo*& groupInfo, uint64_t value = 0)
     {
         auto info = _groups.find(group);
         if (info != _groups.end())
         {
             groupInfo = &(info->second);
-            info->second.Real++;
-
+            info->second.RealCount++;
+            info->second.RealValue += value;
             return;
         }
 
         // need to add the info of this new group
         GroupInfo gi;
-        gi.Real = 1;
-        gi.Sampled = 0;
+        gi.RealCount = 1;
+        gi.SampledCount = 0;
+        gi.RealValue = value;
+        gi.SampledValue = 0;
         auto slot = _groups.insert_or_assign(group, gi);
         groupInfo = &((*slot.first).second);
     }
@@ -95,17 +103,19 @@ class GroupSampler : public GenericSampler
 
         upscaleGroups.reserve(_groups.size());
 
-        for (auto& [name, counts] : _groups)
+        for (auto& [name, info] : _groups)
         {
-            auto sampledCount = counts.Sampled;
+            auto sampledCount = info.SampledCount;
             if (sampledCount > 0)
             {
-                upscaleGroups.push_back(UpscaleGroupInfo<TGroup>{name, counts.Real, sampledCount});
+                upscaleGroups.push_back(UpscaleGroupInfo<TGroup>{name, info.RealCount, sampledCount, info.RealValue, info.SampledValue});
             }
 
             // reset groups count
-            counts.Real = 0;
-            counts.Sampled = 0;
+            info.RealCount = 0;
+            info.SampledCount = 0;
+            info.RealValue = 0;
+            info.SampledValue = 0;
         }
 
         return upscaleGroups;

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

@@ -480,7 +480,20 @@ void LibddprofExporter::AddUpscalingRules(ddog_prof_Profile* profile, std::vecto
             ddog_CharSlice labelName = FfiHelper::StringToCharSlice(upscalingInfo.LabelName);
             ddog_CharSlice groupName = FfiHelper::StringToCharSlice(group.Group);
 
-            auto upscalingRuleAdd = ddog_prof_Profile_add_upscaling_rule_proportional(profile, offsets_slice, labelName, groupName, group.SampledCount, group.RealCount);
+            // upscaling could be based on count (exceptions) or value (lock contention)
+            uint64_t sampled = group.SampledCount;
+            if (group.SampledValue != 0)
+            {
+                sampled = group.SampledValue;
+            }
+
+            uint64_t real = group.RealCount;
+            if (group.RealValue != 0)
+            {
+                real = group.RealValue;
+            }
+
+            auto upscalingRuleAdd = ddog_prof_Profile_add_upscaling_rule_proportional(profile, offsets_slice, labelName, groupName, sampled, real);
             if (upscalingRuleAdd.tag == DDOG_PROF_PROFILE_UPSCALING_RULE_ADD_RESULT_ERR)
             {
                 auto errorMessage = ddog_Error_message(&upscalingRuleAdd.err);

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

@@ -42,8 +42,8 @@ class RawContentionSample : public RawSample
 
         sample->AddLabel(Label{BucketLabelName, std::move(Bucket)});
         sample->AddValue(1, contentionCountIndex);
-        sample->AddLabel(Label{RawCountLabelName, std::to_string(1)});
-        sample->AddLabel(Label{RawDurationLabelName, std::to_string(static_cast<uint64_t>(ContentionDuration))});
+        sample->AddNumericLabel(NumericLabel{RawCountLabelName, 1});
+        sample->AddNumericLabel(NumericLabel{RawDurationLabelName, static_cast<uint64_t>(ContentionDuration)});
         sample->AddValue(static_cast<std::int64_t>(ContentionDuration), contentionDurationIndex);
     }