fix: add sort before hashing attributes (#51)

Closes #48

Author: hendriknielaender

src/attributes.zig

@@ -118,10 +118,29 @@ pub const Attributes = struct {
     }
 
     pub const HashContext = struct {
-        pub fn hash(_: HashContext, self: Self) u64 {
+        fn compareAttributes(context: void, a: Attribute, b: Attribute) bool {
+            _ = context;
+            return std.mem.lessThan(u8, a.key, b.key);
+        }
+
+        const MAX_ATTRS = 128;
+
+        pub fn hash(_: HashContext, self: Attributes) u64 {
             var h = std.hash.Wyhash.init(0);
             const attrs = self.attributes orelse &[_]Attribute{};
-            for (attrs) |attr| {
+
+            // Enforce soft limit: only hash up to MAX_ATTRS attributes
+            const count = @min(attrs.len, MAX_ATTRS);
+
+            var buffer: [MAX_ATTRS]Attribute = undefined;
+            const to_sort = buffer[0..count];
+            @memcpy(to_sort, attrs[0..count]);
+
+            if (to_sort.len > 1) {
+                std.mem.sort(Attribute, to_sort, {}, compareAttributes);
+            }
+
+            for (to_sort) |attr| {
                 h.update(attr.key);
                 h.update(attr.value.toStringNoAlloc());
             }

src/scope.zig

@@ -91,3 +91,21 @@ test "InstrumentationScope should equal correctly" {
 
     try std.testing.expect(hashContext.eql(first, second));
 }
+
+test "InstrumentationScope hash should be consistent regardless of attribute order" {
+    const allocator = std.testing.allocator;
+
+    const attrs1 = try Attributes.from(allocator, .{ "key1", @as(u64, 42), "key2", true, "key3", @as([]const u8, "value3") });
+    defer allocator.free(attrs1.?);
+
+    const attrs2 = try Attributes.from(allocator, .{ "key3", @as([]const u8, "value3"), "key1", @as(u64, 42), "key2", true });
+    defer allocator.free(attrs2.?);
+
+    const scope1: InstrumentationScope = .{ .name = "testScope", .attributes = attrs1 };
+    const scope2: InstrumentationScope = .{ .name = "testScope", .attributes = attrs2 };
+
+    const hashContext = InstrumentationScope.HashContext{};
+
+    try std.testing.expectEqual(hashContext.hash(scope1), hashContext.hash(scope2));
+    try std.testing.expect(hashContext.eql(scope1, scope2));
+}