Skip to content

Commit a80b33c

Browse files
sighphyresighphyre
authored
Revert "feat: counter, gauge, histogram data type implementations (#78)" (#83)
This reverts commit 8ccfed2.
1 parent 8ccfed2 commit a80b33c

File tree

5 files changed

+45
-512
lines changed

5 files changed

+45
-512
lines changed

‎dotnet-engine/Yggdrasil.Engine.Tests/YggdrasilImpactMetricsTest.cs‎

Lines changed: 8 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,16 @@
1-
using System.Collections.Generic;
1+
using System;
2+
using System.Text.Json;
23
using NUnit.Framework;
34
using Yggdrasil;
5+
using Yggdrasil.Test;
46

57
public class YggdrasilImpactMetricsTest
68
{
9+
private JsonSerializerOptions options = new JsonSerializerOptions
10+
{
11+
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
12+
};
13+
714
[Test]
815
public void DefineCounter_Throws_Only_When_Invalid()
916
{
@@ -13,77 +20,4 @@ public void DefineCounter_Throws_Only_When_Invalid()
1320
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineCounter(null!, "Measures time spent on server doing things"));
1421
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineCounter(null!, null!));
1522
}
16-
17-
[Test]
18-
public void IncCounter_Throws_Only_When_Invalid()
19-
{
20-
var yggdrasilEngine = new YggdrasilEngine();
21-
yggdrasilEngine.DefineCounter("requests_total", "Total requests");
22-
23-
Assert.DoesNotThrow(() => yggdrasilEngine.IncCounter("requests_total"));
24-
Assert.DoesNotThrow(() => yggdrasilEngine.IncCounter("requests_total", 5));
25-
Assert.DoesNotThrow(() => yggdrasilEngine.IncCounter("requests_total", 3, new Dictionary<string, string> { { "env", "test" } }));
26-
27-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.IncCounter(null!));
28-
}
29-
30-
[Test]
31-
public void DefineGauge_Throws_Only_When_Invalid()
32-
{
33-
var yggdrasilEngine = new YggdrasilEngine();
34-
Assert.DoesNotThrow(() => yggdrasilEngine.DefineGauge("cpu_usage", "CPU usage"));
35-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineGauge("cpu_usage", null!));
36-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineGauge(null!, "CPU usage"));
37-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineGauge(null!, null!));
38-
}
39-
40-
[Test]
41-
public void SetGauge_Throws_Only_When_Invalid()
42-
{
43-
var yggdrasilEngine = new YggdrasilEngine();
44-
yggdrasilEngine.DefineGauge("queue_depth", "Queue depth");
45-
46-
Assert.DoesNotThrow(() => yggdrasilEngine.SetGauge("queue_depth", 10.5));
47-
Assert.DoesNotThrow(() => yggdrasilEngine.SetGauge("queue_depth", 5.25, new Dictionary<string, string> { { "env", "prod" } }));
48-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.SetGauge(null!, 1.0));
49-
}
50-
51-
[Test]
52-
public void DefineHistogram_Throws_Only_When_Invalid()
53-
{
54-
var yggdrasilEngine = new YggdrasilEngine();
55-
Assert.DoesNotThrow(() => yggdrasilEngine.DefineHistogram("request_duration", "Request duration"));
56-
Assert.DoesNotThrow(() => yggdrasilEngine.DefineHistogram("request_duration_custom", "Request duration custom", new[] { 0.1, 0.5, 1.0, 5.0 }));
57-
58-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineHistogram("request_duration", null!));
59-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineHistogram(null!, "Request duration"));
60-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.DefineHistogram(null!, null!));
61-
}
62-
63-
[Test]
64-
public void ObserveHistogram_Throws_Only_When_Invalid()
65-
{
66-
var yggdrasilEngine = new YggdrasilEngine();
67-
yggdrasilEngine.DefineHistogram("request_duration", "Request duration", new[] { 0.1, 0.5, 1.0, 5.0 });
68-
69-
Assert.DoesNotThrow(() => yggdrasilEngine.ObserveHistogram("request_duration", 0.05));
70-
Assert.DoesNotThrow(() => yggdrasilEngine.ObserveHistogram("request_duration", 0.75, new Dictionary<string, string> { { "env", "test" } }));
71-
Assert.Throws<YggdrasilEngineException>(() => yggdrasilEngine.ObserveHistogram(null!, 1.0));
72-
}
73-
74-
[Test]
75-
public void ImpactMetrics_Methods_Can_Be_Used_Together()
76-
{
77-
var yggdrasilEngine = new YggdrasilEngine();
78-
79-
Assert.DoesNotThrow(() =>
80-
{
81-
yggdrasilEngine.DefineCounter("test_counter", "Test counter");
82-
yggdrasilEngine.IncCounter("test_counter", 10);
83-
yggdrasilEngine.DefineGauge("test_gauge", "Test gauge");
84-
yggdrasilEngine.SetGauge("test_gauge", 42);
85-
yggdrasilEngine.DefineHistogram("test_histogram", "Test histogram", new[] { 0.1, 0.5, 1.0 });
86-
yggdrasilEngine.ObserveHistogram("test_histogram", 0.25);
87-
});
88-
}
8923
}

‎dotnet-engine/Yggdrasil.Engine/Flat.cs‎

Lines changed: 34 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ namespace Yggdrasil;
44

55
internal static class Flat
66
{
7-
private readonly static IntPtr _libHandle;
7+
private static IntPtr _libHandle;
88

99
static Flat()
1010
{
@@ -17,11 +17,6 @@ static Flat()
1717
built_in_strategies = Marshal.GetDelegateForFunctionPointer<BuiltInStrategiesDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_built_in_strategies"));
1818
get_metrics = Marshal.GetDelegateForFunctionPointer<GetMetricsDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_get_metrics"));
1919
define_counter = Marshal.GetDelegateForFunctionPointer<DefineCounterDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_define_counter"));
20-
inc_counter = Marshal.GetDelegateForFunctionPointer<IncCounterDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_inc_counter"));
21-
define_gauge = Marshal.GetDelegateForFunctionPointer<DefineGaugeDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_define_gauge"));
22-
set_gauge = Marshal.GetDelegateForFunctionPointer<SetGaugeDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_set_gauge"));
23-
define_histogram = Marshal.GetDelegateForFunctionPointer<DefineHistogramDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_define_histogram"));
24-
observe_histogram = Marshal.GetDelegateForFunctionPointer<ObserveHistogramDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_observe_histogram"));
2520
}
2621

2722
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
@@ -33,42 +28,29 @@ static Flat()
3328
private delegate Buf CheckEnabledDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
3429

3530
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
36-
private delegate Buf CheckVariantDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
31+
public delegate Buf CheckVariantDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
3732

3833
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
39-
private delegate Buf ListKnownTogglesDelegate(IntPtr enginePtr);
34+
public delegate Buf ListKnownTogglesDelegate(IntPtr enginePtr);
4035

4136
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
42-
private delegate Buf BuiltInStrategiesDelegate();
37+
public delegate Buf BuiltInStrategiesDelegate();
4338

4439
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
45-
private delegate Buf GetMetricsDelegate(IntPtr enginePtr);
40+
public delegate Buf GetMetricsDelegate(IntPtr enginePtr);
4641

4742
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
48-
private delegate Buf DefineCounterDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
49-
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
50-
private delegate Buf IncCounterDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
51-
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
52-
private delegate Buf DefineGaugeDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
53-
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
54-
private delegate Buf SetGaugeDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
55-
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
56-
private delegate Buf DefineHistogramDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
57-
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
58-
private delegate Buf ObserveHistogramDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
43+
public delegate Buf DefineCounterDelegate(IntPtr enginePtr, IntPtr messagePtr, nuint messageLen);
44+
5945
private static readonly TakeStateDelegate take_state;
6046
private static readonly FreeBufferDelegate free_buffer;
6147
private static readonly CheckEnabledDelegate check_enabled;
6248
private static readonly CheckVariantDelegate check_variant;
6349
private static readonly ListKnownTogglesDelegate list_known_toggles;
6450
private static readonly BuiltInStrategiesDelegate built_in_strategies;
6551
private static readonly GetMetricsDelegate get_metrics;
52+
6653
private static readonly DefineCounterDelegate define_counter;
67-
private static readonly IncCounterDelegate inc_counter;
68-
private static readonly DefineGaugeDelegate define_gauge;
69-
private static readonly SetGaugeDelegate set_gauge;
70-
private static readonly DefineHistogramDelegate define_histogram;
71-
private static readonly ObserveHistogramDelegate observe_histogram;
7254

7355
public static Buf TakeState(IntPtr ptr, string json)
7456
{
@@ -77,14 +59,33 @@ public static Buf TakeState(IntPtr ptr, string json)
7759

7860
public static Buf CheckEnabled(IntPtr ptr, byte[] message)
7961
{
80-
return CallWithPinnedBytes(message, (msgPtr, len) => check_enabled(ptr, msgPtr, len));
62+
nuint len = (nuint)message.Length;
63+
GCHandle handle = GCHandle.Alloc(message, GCHandleType.Pinned);
64+
try
65+
{
66+
IntPtr msgPtr = handle.AddrOfPinnedObject();
67+
return check_enabled(ptr, msgPtr, len);
68+
}
69+
finally
70+
{
71+
handle.Free();
72+
}
8173
}
8274

8375
public static Buf CheckVariant(IntPtr ptr, byte[] message)
8476
{
85-
return CallWithPinnedBytes(message, (msgPtr, len) => check_variant(ptr, msgPtr, len));
77+
nuint len = (nuint)message.Length;
78+
GCHandle handle = GCHandle.Alloc(message, GCHandleType.Pinned);
79+
try
80+
{
81+
IntPtr msgPtr = handle.AddrOfPinnedObject();
82+
return check_variant(ptr, msgPtr, len);
83+
}
84+
finally
85+
{
86+
handle.Free();
87+
}
8688
}
87-
8889
public static Buf ListKnownToggles(IntPtr ptr)
8990
{
9091
return list_known_toggles(ptr);
@@ -102,43 +103,12 @@ public static Buf GetMetrics(IntPtr ptr)
102103

103104
public static Buf DefineCounter(IntPtr ptr, byte[] message)
104105
{
105-
return CallWithPinnedBytes(message, (msgPtr, len) => define_counter(ptr, msgPtr, len));
106-
}
107-
108-
public static Buf IncCounter(IntPtr ptr, byte[] message)
109-
{
110-
return CallWithPinnedBytes(message, (msgPtr, len) => inc_counter(ptr, msgPtr, len));
111-
}
112-
113-
public static Buf DefineGauge(IntPtr ptr, byte[] message)
114-
{
115-
return CallWithPinnedBytes(message, (msgPtr, len) => define_gauge(ptr, msgPtr, len));
116-
}
117-
118-
public static Buf SetGauge(IntPtr ptr, byte[] message)
119-
{
120-
return CallWithPinnedBytes(message, (msgPtr, len) => set_gauge(ptr, msgPtr, len));
121-
}
122-
123-
public static Buf DefineHistogram(IntPtr ptr, byte[] message)
124-
{
125-
return CallWithPinnedBytes(message, (msgPtr, len) => define_histogram(ptr, msgPtr, len));
126-
}
127-
128-
public static Buf ObserveHistogram(IntPtr ptr, byte[] message)
129-
{
130-
return CallWithPinnedBytes(message, (msgPtr, len) => observe_histogram(ptr, msgPtr, len));
131-
}
132-
133-
private static Buf CallWithPinnedBytes(byte[] message, Func<IntPtr, nuint, Buf> invoker)
134-
{
135-
if (message is null) throw new ArgumentNullException(nameof(message));
136-
137-
var len = (nuint)message.Length;
138-
var handle = GCHandle.Alloc(message, GCHandleType.Pinned);
106+
nuint len = (nuint)message.Length;
107+
GCHandle handle = GCHandle.Alloc(message, GCHandleType.Pinned);
139108
try
140109
{
141-
return invoker(handle.AddrOfPinnedObject(), len);
110+
IntPtr msgPtr = handle.AddrOfPinnedObject();
111+
return define_counter(ptr, msgPtr, len);
142112
}
143113
finally
144114
{

‎dotnet-engine/Yggdrasil.Engine/Flatbuffers.cs‎

Lines changed: 1 addition & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -64,118 +64,6 @@ public static byte[] CreateDefineCounterBuffer(FlatBufferBuilder builder, string
6464
return builder.SizedByteArray();
6565
}
6666

67-
public static byte[] CreateIncCounterBuffer(FlatBufferBuilder builder, string name, long value, IDictionary<string, string>? labels = null)
68-
{
69-
var nameOffset = builder.CreateString(name);
70-
var labelsOffset = CreateSampleLabelsVector(builder, labels);
71-
72-
IncCounter.StartIncCounter(builder);
73-
IncCounter.AddName(builder, nameOffset);
74-
IncCounter.AddValue(builder, value);
75-
if (labelsOffset.HasValue)
76-
{
77-
IncCounter.AddLabels(builder, labelsOffset.Value);
78-
}
79-
80-
var incCounterMessage = IncCounter.EndIncCounter(builder);
81-
builder.Finish(incCounterMessage.Value);
82-
return builder.SizedByteArray();
83-
}
84-
85-
public static byte[] CreateDefineGaugeBuffer(FlatBufferBuilder builder, string name, string help)
86-
{
87-
var nameOffset = builder.CreateString(name);
88-
var helpOffset = builder.CreateString(help);
89-
90-
DefineGauge.StartDefineGauge(builder);
91-
DefineGauge.AddName(builder, nameOffset);
92-
DefineGauge.AddHelp(builder, helpOffset);
93-
94-
var defineGaugeMessage = DefineGauge.EndDefineGauge(builder);
95-
builder.Finish(defineGaugeMessage.Value);
96-
return builder.SizedByteArray();
97-
}
98-
99-
public static byte[] CreateSetGaugeBuffer(FlatBufferBuilder builder, string name, double value, IDictionary<string, string>? labels = null)
100-
{
101-
var nameOffset = builder.CreateString(name);
102-
var labelsOffset = CreateSampleLabelsVector(builder, labels);
103-
104-
SetGauge.StartSetGauge(builder);
105-
SetGauge.AddName(builder, nameOffset);
106-
SetGauge.AddValue(builder, value);
107-
if (labelsOffset.HasValue)
108-
{
109-
SetGauge.AddLabels(builder, labelsOffset.Value);
110-
}
111-
112-
var setGaugeMessage = SetGauge.EndSetGauge(builder);
113-
builder.Finish(setGaugeMessage.Value);
114-
return builder.SizedByteArray();
115-
}
116-
117-
public static byte[] CreateDefineHistogramBuffer(FlatBufferBuilder builder, string name, string help, IEnumerable<double>? buckets = null)
118-
{
119-
var nameOffset = builder.CreateString(name);
120-
var helpOffset = builder.CreateString(help);
121-
var bucketArray = (buckets ?? Enumerable.Empty<double>()).ToArray();
122-
var bucketsOffset = bucketArray.Length > 0
123-
? DefineHistogram.CreateBucketsVector(builder, bucketArray)
124-
: default(VectorOffset);
125-
126-
DefineHistogram.StartDefineHistogram(builder);
127-
DefineHistogram.AddName(builder, nameOffset);
128-
DefineHistogram.AddHelp(builder, helpOffset);
129-
if (bucketArray.Length > 0)
130-
{
131-
DefineHistogram.AddBuckets(builder, bucketsOffset);
132-
}
133-
134-
var defineHistogramMessage = DefineHistogram.EndDefineHistogram(builder);
135-
builder.Finish(defineHistogramMessage.Value);
136-
return builder.SizedByteArray();
137-
}
138-
139-
public static byte[] CreateObserveHistogramBuffer(FlatBufferBuilder builder, string name, double value, IDictionary<string, string>? labels = null)
140-
{
141-
var nameOffset = builder.CreateString(name);
142-
var labelsOffset = CreateSampleLabelsVector(builder, labels);
143-
144-
ObserveHistogram.StartObserveHistogram(builder);
145-
ObserveHistogram.AddName(builder, nameOffset);
146-
ObserveHistogram.AddValue(builder, value);
147-
if (labelsOffset.HasValue)
148-
{
149-
ObserveHistogram.AddLabels(builder, labelsOffset.Value);
150-
}
151-
152-
var observeHistogramMessage = ObserveHistogram.EndObserveHistogram(builder);
153-
builder.Finish(observeHistogramMessage.Value);
154-
return builder.SizedByteArray();
155-
}
156-
157-
private static VectorOffset? CreateSampleLabelsVector(FlatBufferBuilder builder, IDictionary<string, string>? labels)
158-
{
159-
if (labels == null || labels.Count == 0)
160-
{
161-
return null;
162-
}
163-
164-
var labelEntries = new Offset<SampleLabelEntry>[labels.Count];
165-
var index = 0;
166-
foreach (var kvp in labels)
167-
{
168-
labelEntries[index] = SampleLabelEntry.CreateSampleLabelEntry(
169-
builder,
170-
builder.CreateString(kvp.Key),
171-
builder.CreateString(kvp.Value)
172-
);
173-
index++;
174-
}
175-
176-
return IncCounter.CreateLabelsVector(builder, labelEntries);
177-
}
178-
17967
internal static VectorOffset CreatePropertiesVector(FlatBufferBuilder builder, Context context)
18068
{
18169
var propertyEntries = new Offset<PropertyEntry>[context.Properties?.Count ?? 0];
@@ -350,4 +238,4 @@ private static Dictionary<string, long> GetVariantCounts(ToggleStats stats)
350238
.ToDictionary(x => x.Key, v => v.Value);
351239
}
352240

353-
}
241+
}

0 commit comments

Comments
 (0)