diff --git a/pp/bare_bones/concepts.h b/pp/bare_bones/concepts.h
index 605e0aac5..d211df04d 100644
--- a/pp/bare_bones/concepts.h
+++ b/pp/bare_bones/concepts.h
@@ -71,4 +71,7 @@ concept SteadyClockInterface = requires(Clock& clock) {
   { clock.now() };
 };
 
+template <class T>
+concept arithmetic = std::integral<T> || std::floating_point<T>;
+
 }  // namespace BareBones::concepts
diff --git a/pp/bare_bones/snug_composite.h b/pp/bare_bones/snug_composite.h
index e8526fe41..f16e16a87 100644
--- a/pp/bare_bones/snug_composite.h
+++ b/pp/bare_bones/snug_composite.h
@@ -79,8 +79,8 @@ class GenericDecodingTable {
     const GenericDecodingTable* decoding_table;
     PROMPP_ALWAYS_INLINE explicit Hasher(const GenericDecodingTable* _decoding_table = nullptr) noexcept : decoding_table(_decoding_table) {}
 
-    PROMPP_ALWAYS_INLINE size_t operator()(const std::string_view& str) const noexcept { return XXHash::hash(str); }
-    PROMPP_ALWAYS_INLINE size_t operator()(const std::string& str) const noexcept { return XXHash::hash(str); }
+    PROMPP_ALWAYS_INLINE size_t operator()(const std::string_view& str) const noexcept { return XXHash3::hash(str); }
+    PROMPP_ALWAYS_INLINE size_t operator()(const std::string& str) const noexcept { return XXHash3::hash(str); }
 
     template <class Class>
     PROMPP_ALWAYS_INLINE size_t operator()(const Class& c) const noexcept {
diff --git a/pp/bare_bones/tests/snug_composite_tests.cpp b/pp/bare_bones/tests/snug_composite_tests.cpp
index 49f8b51ff..017cd7dec 100644
--- a/pp/bare_bones/tests/snug_composite_tests.cpp
+++ b/pp/bare_bones/tests/snug_composite_tests.cpp
@@ -141,7 +141,7 @@ TYPED_TEST(SnugComposite, should_return_same_id_for_same_data_with_hash) {
   this->fill_table_with_random_values(outcomes);
 
   std::string v = "12";
-  auto hash_val = BareBones::XXHash::hash(v);
+  auto hash_val = BareBones::XXHash3::hash(v);
   auto id = outcomes.find_or_emplace(v, hash_val);
 
   EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
@@ -151,7 +151,7 @@ TYPED_TEST(SnugComposite, should_return_same_id_for_same_data_with_hash) {
   EXPECT_EQ(outcomes.find_or_emplace(v, hash_val), outcomes.find(v));
 
   v = "21";
-  hash_val = BareBones::XXHash::hash(v);
+  hash_val = BareBones::XXHash3::hash(v);
   id = outcomes.find_or_emplace(v);
 
   EXPECT_EQ(id, outcomes.find_or_emplace(v, hash_val));
diff --git a/pp/bare_bones/xxhash.h b/pp/bare_bones/xxhash.h
index da670fe88..3d0c2968d 100644
--- a/pp/bare_bones/xxhash.h
+++ b/pp/bare_bones/xxhash.h
@@ -12,7 +12,7 @@ PRAGMA_DIAGNOSTIC(pop)
 
 namespace BareBones {
 
-class XXHash {
+class XXHash3 {
  public:
   template <class Number>
     requires std::is_arithmetic_v<Number>
@@ -30,15 +30,15 @@ class XXHash {
   [[nodiscard]] PROMPP_ALWAYS_INLINE uint64_t hash() const noexcept { return hash_; }
   [[nodiscard]] explicit PROMPP_ALWAYS_INLINE operator uint64_t() const noexcept { return hash_; }
 
-  auto operator<=>(const XXHash& other) const noexcept = default;
+  auto operator<=>(const XXHash3& other) const noexcept = default;
 
-  XXHash& operator=(uint64_t hash) noexcept {
+  XXHash3& operator=(uint64_t hash) noexcept {
     hash_ = hash;
     return *this;
   }
 
   PROMPP_ALWAYS_INLINE static uint64_t hash(const char* data, size_t size) noexcept {
-    XXHash hasher;
+    XXHash3 hasher;
     hasher.extend(data, size);
     return hasher.hash();
   }
@@ -50,4 +50,15 @@ class XXHash {
   uint64_t hash_{};
 };
 
+class XXHash {
+ public:
+  PROMPP_ALWAYS_INLINE XXHash() { XXH64_reset(&state_, 0); }
+
+  PROMPP_ALWAYS_INLINE void extend(std::string_view data) noexcept { XXH64_update(&state_, data.data(), data.length()); }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint64_t digest() const noexcept { return XXH64_digest(&state_); }
+
+ private:
+  XXH64_state_t state_;
+};
+
 }  // namespace BareBones
diff --git a/pp/entrypoint/go_constants.cpp b/pp/entrypoint/go_constants.cpp
index ed3a78f32..6befdd173 100644
--- a/pp/entrypoint/go_constants.cpp
+++ b/pp/entrypoint/go_constants.cpp
@@ -1,6 +1,7 @@
 #include "go_constants.h"
 
 #include "head/serialization.h"
+#include "metrics/storage.h"
 #include "prometheus/relabeler.h"
 
 namespace {
@@ -13,4 +14,6 @@ static_assert(sizeof(PromPP::Prometheus::Relabel::InnerSeries) == Sizeof_InnerSe
 
 static_assert(sizeof(entrypoint::head::SerializedDataIterator) == Sizeof_SerializedDataIterator);
 
+static_assert(sizeof(metrics::Storage::Iterator) == Sizeof_MetricsIterator);
+
 }  // namespace
\ No newline at end of file
diff --git a/pp/entrypoint/go_constants.h b/pp/entrypoint/go_constants.h
index ec74157b1..82f538a5d 100644
--- a/pp/entrypoint/go_constants.h
+++ b/pp/entrypoint/go_constants.h
@@ -5,3 +5,5 @@
 #define Sizeof_InnerSeries (Sizeof_SizeT + Sizeof_BareBonesVector + Sizeof_RoaringBitset)
 
 #define Sizeof_SerializedDataIterator 192
+
+#define Sizeof_MetricsIterator 24
diff --git a/pp/entrypoint/metrics.cpp b/pp/entrypoint/metrics.cpp
index 32e11daf0..f83820c0b 100644
--- a/pp/entrypoint/metrics.cpp
+++ b/pp/entrypoint/metrics.cpp
@@ -1,69 +1,47 @@
 #include "metrics.h"
 
-#include <memory>
-
-#include "metrics/counter.h"
-#include "metrics/serializer.h"
 #include "metrics/storage.h"
 #include "primitives/go_model.h"
 #include "primitives/go_slice.h"
 
-struct MetricsIterator {
-  metrics::Storage::Iterator iterator{metrics::storage().begin()};
-  metrics::Serializer serializer;
-};
-
-using MetricsIteratorPtr = std::unique_ptr<MetricsIterator>;
-
 using PromPP::Primitives::Go::Label;
 using PromPP::Primitives::Go::SliceView;
 using PromPP::Primitives::Go::String;
 
-extern "C" void prompp_metrics_iterator_ctor(void* res) {
-  struct Result {
-    MetricsIteratorPtr iterator;
-  };
-
+extern "C" void prompp_metrics_iterator_ctor(void* args) {
   metrics::storage().remove_unused_pages();
 
-  new (res) Result{.iterator = std::make_unique<MetricsIterator>()};
+  std::construct_at(static_cast<metrics::Storage::Iterator*>(args), metrics::storage().begin());
 }
 
-extern "C" void prompp_metrics_iterator_dtor(void* args) {
+extern "C" void prompp_metrics_iterator_next(void* args, void* res) {
   struct Arguments {
-    MetricsIteratorPtr iterator;
-  };
-
-  static_cast<Arguments*>(args)->~Arguments();
-}
-
-extern "C" void prompp_metrics_iterator_serialize(void* args, void* res) {
-  struct Arguments {
-    MetricsIteratorPtr iterator;
+    metrics::Storage::Iterator* iterator;
   };
   struct Result {
-    SliceView<const char> buffer;
+    const PromPP::Primitives::Go::Metric* metric;
   };
 
-  const auto it = static_cast<Arguments*>(args)->iterator.get();
+  const auto in = static_cast<Arguments*>(args);
   const auto out = static_cast<Result*>(res);
 
-  if (it->iterator == metrics::Storage::end()) [[unlikely]] {
-    out->buffer.reset_to(nullptr, 0, 0);
+  if (*in->iterator == metrics::Storage::end()) [[unlikely]] {
+    out->metric = nullptr;
   } else {
-    const auto& buffer = it->serializer.serialize(it->iterator->page->labels(), it->iterator->metric);
-    out->buffer.reset_to(buffer.c_str(), buffer.size(), buffer.capacity());
-    ++it->iterator;
+    out->metric = (*in->iterator)->go_metric();
+    ++(*in->iterator);
   }
 }
 
 struct MetricsPageForTest final : metrics::MetricsPage<MetricsPageForTest> {
   using MetricsPage::MetricsPage;
 
-  MetricsPageForTest(PromPP::Primitives::LabelViewSet&& label_set, const String& counter_name, uint64_t counter_value)
-      : MetricsPage(std::move(label_set)), emplace_count(static_cast<std::string_view>(counter_name), counter_value) {}
+  MetricsPageForTest(const SliceView<Label>& labels, const String& counter_name, uint64_t counter_value)
+      : emplace_count(labels, static_cast<std::string_view>(counter_name), counter_value),
+        emplace_gauge(labels, static_cast<std::string_view>(counter_name), counter_value) {}
 
-  metrics::Counter<> emplace_count;
+  metrics::Counter emplace_count;
+  metrics::Gauge emplace_gauge;
 };
 
 extern "C" void prompp_metrics_page_for_test_ctor(void* args, void* res) {
@@ -78,11 +56,8 @@ extern "C" void prompp_metrics_page_for_test_ctor(void* args, void* res) {
 
   const auto in = static_cast<Arguments*>(args);
 
-  PromPP::Primitives::LabelViewSet label_set;
-  label_set.append_unsorted(in->labels);
-
   new (res) Result{
-      .page = metrics::CreateMetricsPage<MetricsPageForTest>(std::move(label_set), in->counter_name, in->counter_value),
+      .page = metrics::CreateMetricsPage<MetricsPageForTest>(in->labels, in->counter_name, in->counter_value),
   };
 }
 
diff --git a/pp/entrypoint/metrics.h b/pp/entrypoint/metrics.h
index 192743a6c..3e58cccd6 100644
--- a/pp/entrypoint/metrics.h
+++ b/pp/entrypoint/metrics.h
@@ -3,35 +3,24 @@ extern "C" {
 #endif
 
 /**
- * @brief Create metrics iterator
+ * @brief Initialize metrics iterator
  *
- * @param res {
- *   iterator uintptr // Pointer to constructed iterator
- * }
- */
-void prompp_metrics_iterator_ctor(void* res);
-
-/**
- * @brief Destroy metrics iterator
- *
- * @param args {
- *   iterator uintptr // Pointer to constructed iterator
- * }
+ * @param args *MetricIterator
  */
-void prompp_metrics_iterator_dtor(void* args);
+void prompp_metrics_iterator_ctor(void* args);
 
 /**
  * @brief Serialize metric into protobuf and advance iterator to next metric
  *
  * @param args {
- *   iterator uintptr // Pointer to constructed iterator
+ *   iterator *MetricIterator // Pointer to constructed iterator
  * }
  *
  * @param res {
- *   buffer []bytes // serialized data
+ *   metric *cppbridge.CppMetric // Pointer to go metric
  * }
  */
-void prompp_metrics_iterator_serialize(void* args, void* res);
+void prompp_metrics_iterator_next(void* args, void* res);
 
 /**
  * @brief Create metrics page for test
diff --git a/pp/go/cppbridge/entrypoint.go b/pp/go/cppbridge/entrypoint.go
index 939c09e4e..010a593b0 100644
--- a/pp/go/cppbridge/entrypoint.go
+++ b/pp/go/cppbridge/entrypoint.go
@@ -32,6 +32,7 @@ type (
 	CppBareBonesVector        = [C.Sizeof_BareBonesVector]byte
 	CppRoaringBitset          = [C.Sizeof_RoaringBitset]byte
 	CppSerializedDataIterator = [C.Sizeof_SerializedDataIterator]byte
+	CppMetricsIterator        = [C.Sizeof_MetricsIterator]byte
 )
 
 var (
@@ -3447,49 +3448,35 @@ func prometheusRemapStaleNansState(staleNansState, lsIdsMapping uintptr) {
 	)
 }
 
-func prometheusMetricsIteratorCtor() uintptr {
-	var res struct {
-		iterator uintptr
-	}
+func prometheusMetricsIteratorCtor() CppMetricsIterator {
+	var iterator CppMetricsIterator
 
 	testGC()
 	fastcgo.UnsafeCall1(
 		C.prompp_metrics_iterator_ctor,
-		uintptr(unsafe.Pointer(&res)),
+		uintptr(unsafe.Pointer(&iterator)),
 	)
 
-	return res.iterator
+	return iterator
 }
 
-func prometheusMetricsIteratorDtor(iterator uintptr) {
+func prometheusMetricsIteratorNext(iterator *CppMetricsIterator) *CppMetric {
 	args := struct {
 		iterator uintptr
-	}{iterator}
-
-	testGC()
-	fastcgo.UnsafeCall1(
-		C.prompp_metrics_iterator_dtor,
-		uintptr(unsafe.Pointer(&args)),
-	)
-}
-
-func prometheusMetricsIteratorSerialize(iterator uintptr) []byte {
-	args := struct {
-		iterator uintptr
-	}{iterator}
+	}{uintptr(unsafe.Pointer(iterator))}
 
 	var res struct {
-		data []byte
+		metric *CppMetric
 	}
 
 	testGC()
 	fastcgo.UnsafeCall2(
-		C.prompp_metrics_iterator_serialize,
+		C.prompp_metrics_iterator_next,
 		uintptr(unsafe.Pointer(&args)),
 		uintptr(unsafe.Pointer(&res)),
 	)
 
-	return res.data
+	return res.metric
 }
 
 func prometheusMetricsPageForTestCtor(labels Labels, counterName string, counterValue uint64) uintptr {
diff --git a/pp/go/cppbridge/entrypoint.h b/pp/go/cppbridge/entrypoint.h
index 2d1b7061a..fd663aa9c 100755
--- a/pp/go/cppbridge/entrypoint.h
+++ b/pp/go/cppbridge/entrypoint.h
@@ -40,6 +40,8 @@ void prompp_dump_memory_profile(void* args, void* res);
 #define Sizeof_InnerSeries (Sizeof_SizeT + Sizeof_BareBonesVector + Sizeof_RoaringBitset)
 
 #define Sizeof_SerializedDataIterator 192
+
+#define Sizeof_MetricsIterator 24
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -481,35 +483,24 @@ extern "C" {
 #endif
 
 /**
- * @brief Create metrics iterator
+ * @brief Initialize metrics iterator
  *
- * @param res {
- *   iterator uintptr // Pointer to constructed iterator
- * }
- */
-void prompp_metrics_iterator_ctor(void* res);
-
-/**
- * @brief Destroy metrics iterator
- *
- * @param args {
- *   iterator uintptr // Pointer to constructed iterator
- * }
+ * @param args *MetricIterator
  */
-void prompp_metrics_iterator_dtor(void* args);
+void prompp_metrics_iterator_ctor(void* args);
 
 /**
  * @brief Serialize metric into protobuf and advance iterator to next metric
  *
  * @param args {
- *   iterator uintptr // Pointer to constructed iterator
+ *   iterator *MetricIterator // Pointer to constructed iterator
  * }
  *
  * @param res {
- *   buffer []bytes // serialized data
+ *   metric *cppbridge.CppMetric // Pointer to go metric
  * }
  */
-void prompp_metrics_iterator_serialize(void* args, void* res);
+void prompp_metrics_iterator_next(void* args, void* res);
 
 /**
  * @brief Create metrics page for test
diff --git a/pp/go/cppbridge/metrics.go b/pp/go/cppbridge/metrics.go
index 2bec33ea6..aab1bd427 100644
--- a/pp/go/cppbridge/metrics.go
+++ b/pp/go/cppbridge/metrics.go
@@ -1,27 +1,57 @@
 package cppbridge
 
 import (
+	"github.com/prometheus/client_golang/prometheus"
 	dto "github.com/prometheus/client_model/go"
-	"google.golang.org/protobuf/proto"
 )
 
-func CppMetrics(f func(metric *dto.Metric) bool) {
+type CppMetric struct {
+	descriptor *prometheus.Desc
+	metric     *dto.Metric
+}
+
+func (m *CppMetric) Desc() *prometheus.Desc {
+	return m.descriptor
+}
+
+func (m *CppMetric) Write(out *dto.Metric) error {
+	out.Label = m.metric.Label
+	out.Counter = m.metric.Counter
+	out.Gauge = m.metric.Gauge
+	out.Untyped = m.metric.Untyped
+	return nil
+}
+
+func (m *CppMetric) Labels() Labels {
+	labels := make(Labels, 0, len(m.metric.Label))
+	for _, l := range m.metric.Label {
+		labels = append(labels, Label{Name: *l.Name, Value: *l.Value})
+	}
+	return labels
+}
+
+func CppMetrics(f func(metric *CppMetric) bool) {
 	iterator := prometheusMetricsIteratorCtor()
-	defer func() { prometheusMetricsIteratorDtor(iterator) }()
 
-	metric := dto.Metric{}
 	for {
-		bytes := prometheusMetricsIteratorSerialize(iterator)
-		if len(bytes) == 0 {
+		metric := prometheusMetricsIteratorNext(&iterator)
+		if metric == nil || !f(metric) {
 			break
 		}
+	}
+}
 
-		if err := proto.Unmarshal(bytes, &metric); err == nil {
-			if !f(&metric) {
-				break
-			}
+type CppMetricsCollector struct{}
 
-			metric.Reset()
-		}
+func NewCppMetricsCollector(reg prometheus.Registerer) {
+	_ = reg.Register(&CppMetricsCollector{})
+}
+
+func (c *CppMetricsCollector) Describe(chan<- *prometheus.Desc) {
+}
+
+func (c *CppMetricsCollector) Collect(ch chan<- prometheus.Metric) {
+	for metric := range CppMetrics {
+		ch <- metric
 	}
 }
diff --git a/pp/go/cppbridge/metrics_test.go b/pp/go/cppbridge/metrics_test.go
index 4c17e6275..25cedcfed 100644
--- a/pp/go/cppbridge/metrics_test.go
+++ b/pp/go/cppbridge/metrics_test.go
@@ -1,9 +1,9 @@
 package cppbridge
 
 import (
+	"reflect"
 	"testing"
 
-	dto "github.com/prometheus/client_model/go"
 	"github.com/stretchr/testify/suite"
 )
 
@@ -15,35 +15,15 @@ func TestCppMetricsSuite(t *testing.T) {
 	suite.Run(t, new(CppMetricsSuite))
 }
 
-type cppMetric struct {
-	labels  Labels
-	counter *dto.Counter
-}
-
-func newCppMetric(metric *dto.Metric) cppMetric {
-	m := cppMetric{labels: make(Labels, 0, cap(metric.Label)), counter: metric.Counter}
-	for _, l := range metric.Label {
-		m.labels = append(m.labels, Label{Name: *l.Name, Value: *l.Value})
-	}
-
-	return m
-}
-
-func (s *CppMetricsSuite) getMetrics() []cppMetric {
-	metrics := []cppMetric(nil)
+func (s *CppMetricsSuite) getMetrics() []*CppMetric {
+	metrics := []*CppMetric(nil)
 	for metric := range CppMetrics {
-		metrics = append(metrics, newCppMetric(metric))
+		metrics = append(metrics, metric)
 	}
 
 	return metrics
 }
 
-func (s *CppMetricsSuite) assertCounter(metric cppMetric, expectedLabels Labels, expectedValue float64) {
-	s.Require().NotNil(metric.counter)
-	s.Equal(expectedValue, *metric.counter.Value)
-	s.Equal(expectedLabels, metric.labels)
-}
-
 func (s *CppMetricsSuite) TestNoMetricPages() {
 	// Arrange
 
@@ -65,11 +45,14 @@ func (s *CppMetricsSuite) TestOneMetricsPage() {
 	metrics := s.getMetrics()
 
 	// Assert
-	s.Require().Len(metrics, 1)
-	s.assertCounter(metrics[0], Labels{
-		Label{Name: "__name__", Value: "counter"},
-		Label{Name: "metrics_page", Value: "for_test"},
-	}, float64(counterValue))
+	s.Require().Len(metrics, 2)
+	s.Equal("counter", reflect.ValueOf(metrics[0].descriptor).Elem().FieldByName("fqName").String())
+	s.Equal(metrics[0].metric.Counter.GetValue(), float64(counterValue))
+	s.Equal(Labels{Label{Name: "metrics_page", Value: "for_test"}}, metrics[0].Labels())
+
+	s.Equal("counter", reflect.ValueOf(metrics[1].descriptor).Elem().FieldByName("fqName").String())
+	s.Equal(metrics[1].metric.Gauge.GetValue(), float64(counterValue))
+	s.Equal(Labels{Label{Name: "metrics_page", Value: "for_test"}}, metrics[1].Labels())
 }
 
 func (s *CppMetricsSuite) TestTwoMetricPages() {
@@ -88,13 +71,21 @@ func (s *CppMetricsSuite) TestTwoMetricPages() {
 	metrics := s.getMetrics()
 
 	// Assert
-	s.Require().Len(metrics, 2)
-	s.assertCounter(metrics[0], Labels{
-		Label{Name: "__name__", Value: "counter2"},
-		Label{Name: "metrics_page2", Value: "for_test"},
-	}, float64(counterValue2))
-	s.assertCounter(metrics[1], Labels{
-		Label{Name: "__name__", Value: "counter1"},
-		Label{Name: "metrics_page1", Value: "for_test"},
-	}, float64(counterValue1))
+	s.Require().Len(metrics, 4)
+
+	s.Equal("counter2", reflect.ValueOf(metrics[0].descriptor).Elem().FieldByName("fqName").String())
+	s.Equal(metrics[0].metric.Counter.GetValue(), float64(counterValue2))
+	s.Equal(Labels{Label{Name: "metrics_page2", Value: "for_test"}}, metrics[0].Labels())
+
+	s.Equal("counter2", reflect.ValueOf(metrics[1].descriptor).Elem().FieldByName("fqName").String())
+	s.Equal(metrics[1].metric.Gauge.GetValue(), float64(counterValue2))
+	s.Equal(Labels{Label{Name: "metrics_page2", Value: "for_test"}}, metrics[1].Labels())
+
+	s.Equal("counter1", reflect.ValueOf(metrics[2].descriptor).Elem().FieldByName("fqName").String())
+	s.Equal(metrics[2].metric.Counter.GetValue(), float64(counterValue1))
+	s.Equal(Labels{Label{Name: "metrics_page1", Value: "for_test"}}, metrics[2].Labels())
+
+	s.Equal("counter1", reflect.ValueOf(metrics[3].descriptor).Elem().FieldByName("fqName").String())
+	s.Equal(metrics[3].metric.Gauge.GetValue(), float64(counterValue1))
+	s.Equal(Labels{Label{Name: "metrics_page1", Value: "for_test"}}, metrics[3].Labels())
 }
diff --git a/pp/go/storage/manager.go b/pp/go/storage/manager.go
index 68152197a..168ae0f00 100644
--- a/pp/go/storage/manager.go
+++ b/pp/go/storage/manager.go
@@ -379,6 +379,8 @@ func (m *Manager) initServices(
 			metricsUpdaterCancel()
 		},
 	)
+
+	cppbridge.NewCppMetricsCollector(r)
 }
 
 func (m *Manager) close() {
diff --git a/pp/metrics/counter.h b/pp/metrics/counter.h
deleted file mode 100644
index dfeda18e7..000000000
--- a/pp/metrics/counter.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <atomic>
-
-#include "metric.h"
-#include "serializer.h"
-
-namespace metrics {
-
-template <class Type = uint64_t>
-class Counter final : public Metric {
- public:
-  using Metric::Metric;
-
-  Counter() = delete;
-  explicit Counter(std::string_view name, std::integral auto value = 0) : Metric(name), value_(value) {}
-  Counter(const Counter&) = delete;
-  Counter(Counter&&) noexcept = delete;
-  Counter& operator=(const Counter&) = delete;
-  Counter& operator=(Counter&&) noexcept = delete;
-
-  void serialize(protozero::pbf_writer& writer) const override {
-    enum Tag : int {
-      kValue = 1,
-    };
-
-    protozero::pbf_writer counter_writer(writer, Serializer::Tag::kCounter);
-    counter_writer.add_double(Tag::kValue, static_cast<double>(value_));
-  }
-
-  [[nodiscard]] size_t object_size() const noexcept override { return sizeof(*this); }
-
-  PROMPP_ALWAYS_INLINE void add(std::integral auto count) noexcept { value_ += count; }
-
- private:
-  Type value_{};
-};
-
-template <class Type>
-using AtomicCounter = Counter<std::atomic<Type>>;
-
-}  // namespace metrics
\ No newline at end of file
diff --git a/pp/metrics/metric.h b/pp/metrics/metric.h
index ea38b156d..adfa6a7d1 100644
--- a/pp/metrics/metric.h
+++ b/pp/metrics/metric.h
@@ -1,29 +1,81 @@
 #pragma once
 
-#include "third_party/protozero/pbf_writer.hpp"
-
-#include "bare_bones/preprocess.h"
+#include "bare_bones/concepts.h"
+#include "primitives/go_metric.h"
+#include "primitives/label_set.h"
 
 namespace metrics {
 
 class Metric {
  public:
+  using Label = std::pair<PromPP::Primitives::Go::String, PromPP::Primitives::Go::String>;
+
   Metric() = delete;
-  explicit Metric(std::string_view name) : name_(name) {}
+  template <class LabelSet, class DtoMetricObject>
+    requires std::same_as<DtoMetricObject, PromPP::Primitives::Go::dto::Gauge> || std::same_as<DtoMetricObject, PromPP::Primitives::Go::dto::Counter>
+  Metric(const LabelSet& labels, std::string_view name, DtoMetricObject* object, size_t object_size)
+      : labels_(labels, PromPP::Primitives::NoSortLabels{}),
+        label_pairs_(create_label_pairs()),
+        descriptor_(PromPP::Primitives::Go::String(name), label_pairs_),
+        metric_(PromPP::Primitives::Go::SliceView(descriptor_.const_label_pairs), object),
+        object_size_(object_size) {}
   Metric(const Metric&) = delete;
   Metric(Metric&&) noexcept = delete;
   Metric& operator=(const Metric&) = delete;
   Metric& operator=(Metric&&) noexcept = delete;
-  virtual ~Metric() = default;
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE std::string_view name() const noexcept { return name_; }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t object_size() const noexcept { return object_size_; }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE const PromPP::Primitives::Go::Metric* go_metric() const noexcept { return &go_metric_; }
 
-  virtual void serialize(protozero::pbf_writer& writer) const = 0;
+ private:
+  PromPP::Primitives::BasicLabelSet<Label> labels_;
+  PromPP::Primitives::Go::dto::LabelPairsList label_pairs_;
+  PromPP::Primitives::Go::dto::MetricDescriptor descriptor_;
+  PromPP::Primitives::Go::dto::Metric metric_;
+  PromPP::Primitives::Go::Metric go_metric_{.descriptor = &descriptor_, .metric = &metric_};
+  const size_t object_size_{};
 
-  [[nodiscard]] virtual size_t object_size() const noexcept = 0;
+  PromPP::Primitives::Go::dto::LabelPairsList create_label_pairs() {
+    PromPP::Primitives::Go::dto::LabelPairsList list;
+    list.reserve(labels_.size());
 
- private:
-  std::string_view name_;
+    for (const auto& label : labels_) {
+      list.emplace_back(&label.first, &label.second);
+    }
+
+    return list;
+  }
+};
+
+class Counter final : public Metric {
+ public:
+  using Metric::Metric;
+
+  template <class LabelSet, BareBones::concepts::arithmetic ValueType = double>
+  explicit Counter(LabelSet&& labels, std::string_view name, ValueType value = {})
+      : Metric(std::forward<LabelSet>(labels), name, &counter_, sizeof(*this)), value_(value) {}
+
+  PROMPP_ALWAYS_INLINE void inc(BareBones::concepts::arithmetic auto count) noexcept { value_ += count; }
+
+ protected:
+  double value_{};
+  PromPP::Primitives::Go::dto::Counter counter_{&value_};
+};
+
+class Gauge final : public Metric {
+ public:
+  using Metric::Metric;
+
+  template <class LabelSet, BareBones::concepts::arithmetic ValueType = double>
+  explicit Gauge(LabelSet&& labels, std::string_view name, ValueType value = {})
+      : Metric(std::forward<LabelSet>(labels), name, &gauge_, sizeof(*this)), value_(value) {}
+
+  PROMPP_ALWAYS_INLINE void inc(BareBones::concepts::arithmetic auto count) noexcept { value_ += count; }
+  PROMPP_ALWAYS_INLINE void dec(BareBones::concepts::arithmetic auto count) noexcept { value_ -= count; }
+
+ protected:
+  double value_{};
+  PromPP::Primitives::Go::dto::Gauge gauge_{&value_};
 };
 
 }  // namespace metrics
\ No newline at end of file
diff --git a/pp/metrics/metrics_page.h b/pp/metrics/metrics_page.h
index 09036aab4..d33d52068 100644
--- a/pp/metrics/metrics_page.h
+++ b/pp/metrics/metrics_page.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "label_set.h"
 #include "metric.h"
 
 namespace metrics {
@@ -46,9 +45,7 @@ class MetricsPageControlBlock {
     [[nodiscard]] const Metric* metric() const { return reinterpret_cast<const Metric*>(reinterpret_cast<const uint8_t*>(metrics_page_) + offset_); }
   };
 
-  template <class LabelSet>
-  explicit MetricsPageControlBlock(LabelSet&& label_set, uint32_t page_object_size)
-      : labels_(std::forward<LabelSet>(label_set)), page_object_size_(page_object_size) {}
+  explicit MetricsPageControlBlock(uint32_t page_object_size) : page_object_size_(page_object_size) {}
 
   MetricsPageControlBlock() = delete;
   MetricsPageControlBlock(const MetricsPageControlBlock&) = delete;
@@ -57,7 +54,6 @@ class MetricsPageControlBlock {
   MetricsPageControlBlock& operator=(const MetricsPageControlBlock&) = delete;
   MetricsPageControlBlock& operator=(MetricsPageControlBlock&&) noexcept = delete;
 
-  [[nodiscard]] PROMPP_ALWAYS_INLINE const LabelSet& labels() const noexcept { return labels_; }
   [[nodiscard]] PROMPP_ALWAYS_INLINE MetricsPageControlBlock* next_metrics_page() const noexcept { return next_metrics_page_; }
   PROMPP_ALWAYS_INLINE void set_next_metrics_page(MetricsPageControlBlock* next_metrics_page) noexcept { next_metrics_page_ = next_metrics_page; }
   [[nodiscard]] PROMPP_ALWAYS_INLINE size_t page_object_size() const noexcept { return page_object_size_; }
@@ -68,7 +64,6 @@ class MetricsPageControlBlock {
   [[nodiscard]] PROMPP_ALWAYS_INLINE IteratorSentinel static end() noexcept { return {}; }
 
  private:
-  LabelSet labels_;
   MetricsPageControlBlock* next_metrics_page_{};
   uint32_t ref_count_{1};
   const uint32_t page_object_size_;
@@ -81,12 +76,10 @@ class MetricsPage : public MetricsPageControlBlock {
 
   using MetricsPageControlBlock::MetricsPageControlBlock;
 
-  template <class LabelSet>
-  explicit MetricsPage(LabelSet&& label_set) : MetricsPageControlBlock(std::forward<LabelSet>(label_set), sizeof(Derived)) {
+  explicit MetricsPage() : MetricsPageControlBlock(sizeof(Derived)) {
     static_assert(sizeof(Derived) >= sizeof(MetricsPageControlBlock) + sizeof(Metric), "Metrics page must contain at least one metric");
   }
 
-  MetricsPage() = delete;
   MetricsPage(const MetricsPage&) = delete;
   MetricsPage(MetricsPage&&) noexcept = delete;
 
diff --git a/pp/metrics/metrics_page_list_tests.cpp b/pp/metrics/metrics_page_list_tests.cpp
index c41b99c9a..2d402698f 100644
--- a/pp/metrics/metrics_page_list_tests.cpp
+++ b/pp/metrics/metrics_page_list_tests.cpp
@@ -2,12 +2,10 @@
 
 #include <gtest/gtest.h>
 
-#include "counter.h"
 #include "metrics_page_list.h"
 
 namespace {
 
-using metrics::AtomicCounter;
 using metrics::Counter;
 using metrics::Metric;
 using metrics::MetricsPage;
@@ -22,7 +20,7 @@ class MetricsPageListFixture : public ::testing::Test {
   struct Metrics final : MetricsPage<Metrics> {
     using MetricsPage::MetricsPage;
 
-    Counter<uint16_t> uint64_counter{"uint16_counter", 16};
+    Counter uint64_counter{LabelViewSet{}, "uint16_counter", 16};
   };
 
   MetricsPageList metrics_page_list_;
@@ -47,7 +45,7 @@ TEST_F(MetricsPageListFixture, TestIteratorInEmptyList) {
 
 TEST_F(MetricsPageListFixture, TestIteratorWithUsedPages) {
   // Arrange
-  MetricsPagesVector metrics_pages{new Metrics(LabelViewSet{{"job", "test"}}), new Metrics(LabelViewSet{{"job2", "test2"}})};
+  MetricsPagesVector metrics_pages{new Metrics(), new Metrics()};
   add_metrics_pages(metrics_pages);
 
   MetricsPagesVector actual;
@@ -62,8 +60,7 @@ TEST_F(MetricsPageListFixture, TestIteratorWithUsedPages) {
 
 TEST_F(MetricsPageListFixture, TestIteratorWithUnusedPages) {
   // Arrange
-  const MetricsPagesVector metrics_pages{new Metrics(LabelViewSet{{"job", "test"}}), new Metrics(LabelViewSet{{"job2", "test2"}}),
-                                         new Metrics(LabelViewSet{{"job3", "test3"}}), new Metrics(LabelViewSet{{"job4", "test4"}})};
+  const MetricsPagesVector metrics_pages{new Metrics(), new Metrics(), new Metrics(), new Metrics()};
   metrics_pages[0]->detach();
   metrics_pages[1]->detach();
   metrics_pages[3]->detach();
@@ -82,8 +79,7 @@ TEST_F(MetricsPageListFixture, TestIteratorWithUnusedPages) {
 class MetricsPageListRemoveUnusedPagesFixture : public MetricsPageListFixture {
  protected:
   MetricsPagesVector fill_4_metric_pages() {
-    MetricsPagesVector pages{new Metrics(LabelViewSet{{"job", "test"}}), new Metrics(LabelViewSet{{"job2", "test2"}}),
-                             new Metrics(LabelViewSet{{"job3", "test3"}}), new Metrics(LabelViewSet{{"job4", "test4"}})};
+    MetricsPagesVector pages{new Metrics(), new Metrics(), new Metrics(), new Metrics()};
     add_metrics_pages(pages);
     return pages;
   }
@@ -100,7 +96,7 @@ TEST_F(MetricsPageListRemoveUnusedPagesFixture, TestRemoveInEmptyList) {
 
 TEST_F(MetricsPageListRemoveUnusedPagesFixture, TestRemoveWithoutUnusedPages) {
   // Arrange
-  MetricsPagesVector metrics_pages{new Metrics(LabelViewSet{{"job", "test"}}), new Metrics(LabelViewSet{{"job2", "test2"}})};
+  MetricsPagesVector metrics_pages{new Metrics(), new Metrics()};
   add_metrics_pages(metrics_pages);
 
   MetricsPagesVector actual;
@@ -117,7 +113,7 @@ TEST_F(MetricsPageListRemoveUnusedPagesFixture, TestRemoveWithoutUnusedPages) {
 
 TEST_F(MetricsPageListRemoveUnusedPagesFixture, TestRemoveFirstMetricsPageInOnePageList) {
   // Arrange
-  const auto metric = new Metrics(LabelViewSet{{"job", "test"}});
+  const auto metric = new Metrics();
   metrics_page_list_.add(metric);
   metric->detach();
 
@@ -230,7 +226,7 @@ TEST_F(MetricsPageListThreadSafetyFixture, DISABLED_TestAdd) {
   static constexpr auto kWaitThreadCreationDuration = std::chrono::milliseconds(1000);
 
   MetricsPagesVector pages(kThreadsCount * kThreadTasks);
-  std::ranges::generate(pages, [] { return new Metrics(LabelViewSet{{"job", "test"}}); });
+  std::ranges::generate(pages, [] { return new Metrics(); });
 
   std::vector<std::jthread> threads_list;
   threads_list.reserve(kThreadsCount);
diff --git a/pp/metrics/metrics_page_tests.cpp b/pp/metrics/metrics_page_tests.cpp
index 407566575..9a9a1cbfc 100644
--- a/pp/metrics/metrics_page_tests.cpp
+++ b/pp/metrics/metrics_page_tests.cpp
@@ -1,11 +1,9 @@
 #include <gtest/gtest.h>
 
-#include "counter.h"
 #include "metrics_page.h"
 
 namespace {
 
-using metrics::AtomicCounter;
 using metrics::Counter;
 using metrics::Metric;
 using metrics::MetricsPage;
@@ -21,10 +19,10 @@ TEST_F(MetricsPageFixture, TestIterator) {
   struct Metrics : MetricsPage<Metrics> {
     using MetricsPage::MetricsPage;
 
-    Counter<uint16_t> uint16_counter{"uint16_counter", 16};
-    Counter<uint32_t> uint32_counter{"uint32_counter", 32};
-    AtomicCounter<uint64_t> atomic_counter{"atomic_uint64_counter", 64};
-  } const metrics(LabelViewSet{{"job", "test"}});
+    Counter uint16_counter{LabelViewSet{}, "uint16_counter", 16};
+    Counter uint32_counter{LabelViewSet{}, "uint32_counter", 32};
+    Counter atomic_counter{LabelViewSet{}, "atomic_uint64_counter", 64};
+  } const metrics;
 
   MetricsVector metric_pointers;
 
diff --git a/pp/metrics/serializer.h b/pp/metrics/serializer.h
deleted file mode 100644
index 970acca1b..000000000
--- a/pp/metrics/serializer.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include "label_set.h"
-#include "metric.h"
-
-namespace metrics {
-
-class Serializer {
- public:
-  enum Tag : int {
-    kLabelSet = 1,
-    kCounter = 3,
-  };
-
-  enum LabelSetTag : int {
-    kName = 1,
-    kValue = 2,
-  };
-
-  const std::string& serialize(const LabelSet& label_set, const Metric* metric) {
-    buffer_.clear();
-
-    protozero::pbf_writer writer(buffer_);
-    label_set.set_name(metric->name());
-    serialize_label_set(label_set, writer);
-    metric->serialize(writer);
-    return buffer_;
-  }
-
- private:
-  std::string buffer_;
-
-  static void serialize_label_set(const LabelSet& label_set, protozero::pbf_writer& writer) {
-    for (const auto& label : label_set.labels()) {
-      protozero::pbf_writer label_set_writer(writer, Tag::kLabelSet);
-      label_set_writer.add_string(LabelSetTag::kName, label.first);
-      label_set_writer.add_string(LabelSetTag::kValue, label.second);
-    }
-  }
-};
-
-}  // namespace metrics
\ No newline at end of file
diff --git a/pp/metrics/serializer_tests.cpp b/pp/metrics/serializer_tests.cpp
deleted file mode 100644
index 0ff8d9208..000000000
--- a/pp/metrics/serializer_tests.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "counter.h"
-#include "serializer.h"
-
-namespace {
-
-using metrics::Counter;
-using metrics::LabelSet;
-using metrics::Metric;
-using metrics::Serializer;
-using PromPP::Primitives::LabelViewSet;
-using std::operator""sv;
-
-class SerializeFixture : public testing::Test {
- protected:
-  Serializer serializer_;
-};
-
-TEST_F(SerializeFixture, SerializeCounter) {
-  // Arrange
-  const Counter counter{"my_counter", 1234};
-  const LabelSet label_set(LabelViewSet{{"__name__", "__value__"}, {"name2", "value2"}});
-
-  // Act
-  const auto& buffer = serializer_.serialize(label_set, &counter);
-
-  // Assert
-  EXPECT_EQ(
-      "\x0A\x16\x0A\x08\x5F\x5F\x6E\x61\x6D\x65\x5F\x5F\x12\x0A\x6D\x79\x5F\x63\x6F\x75\x6E\x74\x65\x72\x0A\x0F\x0A\x05\x6E\x61\x6D\x65\x32\x12\x06\x76\x61\x6C"
-      "\x75\x65\x32\x1A\x09\x09\x00\x00\x00\x00\x00\x48\x93\x40"sv,
-      buffer);
-}
-
-}  // namespace
\ No newline at end of file
diff --git a/pp/metrics/storage.h b/pp/metrics/storage.h
index 81f545750..1c3b73694 100644
--- a/pp/metrics/storage.h
+++ b/pp/metrics/storage.h
@@ -10,35 +10,20 @@ class Storage {
 
   class Iterator {
    public:
-    struct Item {
-      const MetricsPageControlBlock* page{};
-      const Metric* metric{};
-
-      bool operator==(const Item&) const noexcept = default;
-    };
-
     using iterator_category = std::forward_iterator_tag;
-    using value_type = Item;
+    using value_type = const Metric*;
     using difference_type = ptrdiff_t;
     using pointer = value_type;
     using reference = value_type;
 
-    explicit Iterator(const MetricsPageList& storage) : page_iterator_(storage.begin()), metric_iterator_(*page_iterator_) {
-      if (metric_iterator_ != MetricsPageControlBlock::end()) {
-        fill_item();
-      }
-    }
+    explicit Iterator(const MetricsPageList& storage) : page_iterator_(storage.begin()), metric_iterator_(*page_iterator_) {}
 
-    [[nodiscard]] PROMPP_ALWAYS_INLINE const value_type& operator*() const noexcept { return item_; }
-    [[nodiscard]] PROMPP_ALWAYS_INLINE const value_type* operator->() const noexcept { return &item_; }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator*() const noexcept { return metric_iterator_.operator*(); }
+    [[nodiscard]] PROMPP_ALWAYS_INLINE value_type operator->() const noexcept { return metric_iterator_.operator->(); }
 
     PROMPP_ALWAYS_INLINE Iterator& operator++() noexcept {
-      if (++metric_iterator_ != MetricsPageControlBlock::end()) {
-        fill_item();
-      } else {
-        if (metric_iterator_ = MetricsPageControlBlock::Iterator(*++page_iterator_); metric_iterator_ != MetricsPageControlBlock::end()) {
-          fill_item();
-        }
+      if (++metric_iterator_ == MetricsPageControlBlock::end()) [[likely]] {
+        metric_iterator_ = MetricsPageControlBlock::Iterator(*++page_iterator_);
       }
 
       return *this;
@@ -55,9 +40,6 @@ class Storage {
    private:
     MetricsPageList::Iterator page_iterator_;
     MetricsPageControlBlock::Iterator metric_iterator_;
-    Item item_;
-
-    void fill_item() { item_ = {.page = *page_iterator_, .metric = *metric_iterator_}; }
   };
 
   PROMPP_ALWAYS_INLINE void add(MetricsPageControlBlock* page) { page_list_.add(page); }
@@ -75,16 +57,16 @@ PROMPP_ALWAYS_INLINE Storage& storage() {
   return storage;
 }
 
-template <class MetricsPageType, class LabelSet, class... Args>
-PROMPP_ALWAYS_INLINE MetricsPageType* CreateMetricsPage(Storage& s, LabelSet&& label_set, Args&&... args) {
-  auto* page = new MetricsPageType(std::forward<LabelSet>(label_set), std::forward<Args>(args)...);
+template <class MetricsPageType, class... Args>
+PROMPP_ALWAYS_INLINE MetricsPageType* CreateMetricsPage(Storage& s, Args&&... args) {
+  auto* page = new MetricsPageType(std::forward<Args>(args)...);
   s.add(page);
   return page;
 }
 
-template <class MetricsPageType, class LabelSet, class... Args>
-PROMPP_ALWAYS_INLINE MetricsPageType* CreateMetricsPage(LabelSet&& label_set, Args&&... args) {
-  return CreateMetricsPage<MetricsPageType>(storage(), std::forward<LabelSet>(label_set), std::forward<Args>(args)...);
+template <class MetricsPageType, class... Args>
+PROMPP_ALWAYS_INLINE MetricsPageType* CreateMetricsPage(Args&&... args) {
+  return CreateMetricsPage<MetricsPageType>(storage(), std::forward<Args>(args)...);
 }
 
 }  // namespace metrics
\ No newline at end of file
diff --git a/pp/metrics/storage_tests.cpp b/pp/metrics/storage_tests.cpp
index e70cca946..ef639110a 100644
--- a/pp/metrics/storage_tests.cpp
+++ b/pp/metrics/storage_tests.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include "counter.h"
 #include "storage.h"
 
 namespace {
@@ -21,20 +20,20 @@ class MetricsStorageIteratorFixture : public testing::Test {
   struct Metrics1 final : MetricsPage<Metrics1> {
     using MetricsPage::MetricsPage;
 
-    Counter<> counter{"counter", 64};
+    Counter counter{LabelViewSet{}, "counter", 64};
   };
 
   struct Metrics2 final : MetricsPage<Metrics2> {
     using MetricsPage::MetricsPage;
 
-    Counter<> counter1{"counter1", 64};
-    Counter<> counter2{"counter2", 64};
+    Counter counter1{LabelViewSet{}, "counter1", 64};
+    Counter counter2{LabelViewSet{}, "counter2", 64};
   };
 };
 
 TEST_F(MetricsStorageIteratorFixture, EmptyStorage) {
   // Arrange
-  std::vector<Storage::Iterator::Item> items;
+  std::vector<Storage::Iterator::value_type> items;
 
   // Act
   std::ranges::copy(storage_, std::back_inserter(items));
@@ -45,20 +44,20 @@ TEST_F(MetricsStorageIteratorFixture, EmptyStorage) {
 
 TEST_F(MetricsStorageIteratorFixture, TwoPages) {
   // Arrange
-  const auto page1 = CreateMetricsPage<Metrics1>(storage_, LabelViewSet{{"page", "1"}});
-  const auto page2 = CreateMetricsPage<Metrics2>(storage_, LabelViewSet{{"page", "2"}});
+  const auto page1 = CreateMetricsPage<Metrics1>(storage_);
+  const auto page2 = CreateMetricsPage<Metrics2>(storage_);
 
-  std::vector<Storage::Iterator::Item> items;
+  std::vector<Storage::Iterator::value_type> items;
 
   // Act
   std::ranges::copy(storage_, std::back_inserter(items));
 
   // Assert
   EXPECT_TRUE(std::ranges::equal(
-      std::vector<Storage::Iterator::Item>{
-          {.page = page2, .metric = &page2->counter1},
-          {.page = page2, .metric = &page2->counter2},
-          {.page = page1, .metric = &page1->counter},
+      std::vector<Storage::Iterator::value_type>{
+          &page2->counter1,
+          &page2->counter2,
+          &page1->counter,
       },
       items));
 }
diff --git a/pp/primitives/go_metric.h b/pp/primitives/go_metric.h
new file mode 100644
index 000000000..db311a30e
--- /dev/null
+++ b/pp/primitives/go_metric.h
@@ -0,0 +1,133 @@
+#pragma once
+
+#include "bare_bones/xxhash.h"
+#include "go_model.h"
+#include "label_set.h"
+
+namespace PromPP::Primitives::Go {
+
+namespace dto {
+
+struct MessageState {
+  void* atomic_message_info{};
+};
+
+using UnknownFields = Slice<uint8_t>;
+using CacheSize = int32_t;
+
+struct LabelPair {
+  PROMPP_ALWAYS_INLINE LabelPair(const String* n, const String* v) : name(n), value(v) {}
+
+  MessageState state{};
+  CacheSize size_cache{};
+  UnknownFields unknown_fields{};
+
+  const String* name;
+  const String* value;
+};
+
+using LabelPairsList = std::vector<LabelPair>;
+
+struct Gauge {
+  explicit Gauge(double* counter) : value(counter) {}
+
+  MessageState state{};
+  CacheSize size_cache{};
+  UnknownFields unknown_fields{};
+
+  double* value{};
+};
+
+struct Counter {
+  explicit Counter(double* counter) : value(counter) {}
+
+  MessageState state{};
+  CacheSize size_cache{};
+  UnknownFields unknown_fields{};
+
+  double* value{};
+  void* exemplar{};
+  void* created_timestamp{};
+};
+
+struct Metric {
+  PROMPP_ALWAYS_INLINE Metric(const SliceView<const LabelPair*>& label_set, Gauge* gauge_ptr) : labels(label_set), gauge(gauge_ptr) {}
+  PROMPP_ALWAYS_INLINE Metric(const SliceView<const LabelPair*>& label_set, Counter* counter_ptr) : labels(label_set), counter(counter_ptr) {}
+
+  MessageState state{};
+  CacheSize size_cache{};
+  UnknownFields unknown_fields{};
+
+  SliceView<const LabelPair*> labels{};
+  Gauge* gauge{};
+  Counter* counter{};
+  void* summary{};
+  void* untyped{};
+  void* histogram{};
+  void* timestamp{};
+};
+
+struct MetricDescriptor {
+  MetricDescriptor(String name, const LabelPairsList& labels) : fq_name(name) {
+    set_const_labels(labels);
+
+    id = calculate_id();
+    dim_hash = calculate_dim_hash();
+  }
+
+  String fq_name;
+  String help{};
+  Slice<const LabelPair*> const_label_pairs{};
+  void* variable_labels{};
+  uint64_t id{};
+  uint64_t dim_hash{};
+  Error error{};
+
+ private:
+  static constexpr std::string_view kSeparator = "\xFF";
+
+  void set_const_labels(const LabelPairsList& labels) {
+    const_label_pairs.reserve(labels.size());
+    for (const auto& label_pair : labels) {
+      const_label_pairs.emplace_back(&label_pair);
+    }
+    std::ranges::sort(const_label_pairs, [](const LabelPair* a, const LabelPair* b) { return a->name < b->name; });
+  }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint64_t calculate_id() const noexcept {
+    BareBones::XXHash hash;
+
+    hash.extend(static_cast<std::string_view>(fq_name));
+    hash.extend(kSeparator);
+
+    for (const auto& label_pair : const_label_pairs) {
+      hash.extend(static_cast<std::string_view>(*label_pair->value));
+      hash.extend(kSeparator);
+    }
+
+    return hash.digest();
+  }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE uint64_t calculate_dim_hash() const noexcept {
+    BareBones::XXHash hash;
+
+    hash.extend(static_cast<std::string_view>(help));
+    hash.extend(kSeparator);
+
+    for (const auto& label_pair : const_label_pairs) {
+      hash.extend(static_cast<std::string_view>(*label_pair->name));
+      hash.extend(kSeparator);
+    }
+
+    return hash.digest();
+  }
+};
+
+}  // namespace dto
+
+struct Metric {
+  dto::MetricDescriptor* descriptor{};
+  dto::Metric* metric{};
+};
+
+}  // namespace PromPP::Primitives::Go
\ No newline at end of file
diff --git a/pp/primitives/go_model.h b/pp/primitives/go_model.h
index 90279835b..b1b3ad121 100644
--- a/pp/primitives/go_model.h
+++ b/pp/primitives/go_model.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <string_view>
 
 #include "primitives/go_slice.h"
@@ -352,6 +353,8 @@ void read_timeseries(const TimeSeries& go_time_series, Timeseries& time_series)
   read_samples(go_time_series, time_series.samples());
 }
 
+using Error = std::array<void*, 2>;
+
 }  // namespace PromPP::Primitives::Go
 
 template <>
diff --git a/pp/primitives/go_slice.h b/pp/primitives/go_slice.h
index e32e113b4..02f5b34dc 100644
--- a/pp/primitives/go_slice.h
+++ b/pp/primitives/go_slice.h
@@ -12,52 +12,6 @@
 #include "bare_bones/vector.h"
 
 namespace PromPP::Primitives::Go {
-template <class T>
-class SliceView {
-  T* data_;
-  size_t len_;
-  size_t cap_;
-
- public:
-  using iterator_category = std::contiguous_iterator_tag;
-  using value_type = const T;
-  using iterator = T*;
-  using const_iterator = const T*;
-
-  PROMPP_ALWAYS_INLINE explicit SliceView() = default;
-
-  PROMPP_ALWAYS_INLINE void reset_to(T* data, size_t len, size_t cap) {
-    data_ = data;
-    len_ = len;
-    cap_ = cap;
-  }
-
-  PROMPP_ALWAYS_INLINE void reset_to(std::span<T> buffer) { reset_to(buffer.data(), buffer.size(), buffer.size()); }
-
-  PROMPP_ALWAYS_INLINE const T* data() const noexcept { return data_; }
-  PROMPP_ALWAYS_INLINE T* data() noexcept { return data_; }
-
-  [[nodiscard]] PROMPP_ALWAYS_INLINE bool empty() const noexcept { return !len_; }
-  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return len_; }
-  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t capacity() const noexcept { return cap_; }
-  [[nodiscard]] PROMPP_ALWAYS_INLINE std::span<const T> span() const noexcept { return {data_, len_}; }
-
-  PROMPP_ALWAYS_INLINE const_iterator begin() const noexcept { return data_; }
-  const_iterator end() const noexcept { return data_ + len_; }
-
-  PROMPP_ALWAYS_INLINE iterator begin() noexcept { return data_; }
-  PROMPP_ALWAYS_INLINE iterator end() noexcept { return data_ + len_; }
-
-  PROMPP_ALWAYS_INLINE const T& operator[](uint32_t i) const {
-    assert(i < len_);
-    return data_[i];
-  }
-
-  PROMPP_ALWAYS_INLINE T& operator[](uint32_t i) {
-    assert(i < len_);
-    return data_[i];
-  }
-};  // class SliceView
 
 class String {
   const char* data_;
@@ -141,6 +95,55 @@ struct SliceControlBlock {
 template <class T>
 using Slice = BareBones::MemoryBasedVector<SliceControlBlock, T>;
 
+template <class T>
+class SliceView {
+  T* data_;
+  size_t len_;
+  size_t cap_;
+
+ public:
+  using iterator_category = std::contiguous_iterator_tag;
+  using value_type = const T;
+  using iterator = T*;
+  using const_iterator = const T*;
+
+  PROMPP_ALWAYS_INLINE SliceView() = default;
+
+  PROMPP_ALWAYS_INLINE explicit SliceView(Slice<T>& slice) : data_(slice.data()), len_(slice.size()), cap_(slice.capacity()) {}
+
+  PROMPP_ALWAYS_INLINE void reset_to(T* data, size_t len, size_t cap) {
+    data_ = data;
+    len_ = len;
+    cap_ = cap;
+  }
+
+  PROMPP_ALWAYS_INLINE void reset_to(std::span<T> buffer) { reset_to(buffer.data(), buffer.size(), buffer.size()); }
+
+  PROMPP_ALWAYS_INLINE const T* data() const noexcept { return data_; }
+  PROMPP_ALWAYS_INLINE T* data() noexcept { return data_; }
+
+  [[nodiscard]] PROMPP_ALWAYS_INLINE bool empty() const noexcept { return !len_; }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t size() const noexcept { return len_; }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE size_t capacity() const noexcept { return cap_; }
+  [[nodiscard]] PROMPP_ALWAYS_INLINE std::span<const T> span() const noexcept { return {data_, len_}; }
+
+  PROMPP_ALWAYS_INLINE const_iterator begin() const noexcept { return data_; }
+  const_iterator end() const noexcept { return data_ + len_; }
+
+  PROMPP_ALWAYS_INLINE iterator begin() noexcept { return data_; }
+  PROMPP_ALWAYS_INLINE iterator end() noexcept { return data_ + len_; }
+
+  PROMPP_ALWAYS_INLINE const T& operator[](uint32_t i) const {
+    assert(i < len_);
+    return data_[i];
+  }
+
+  PROMPP_ALWAYS_INLINE T& operator[](uint32_t i) {
+    assert(i < len_);
+    return data_[i];
+  }
+};
+
 class BytesStream : public std::ostream {
  public:
   explicit BytesStream(Slice<char>* s) : std::ostream(&buffer_), buffer_(s) {}
diff --git a/pp/primitives/hash.h b/pp/primitives/hash.h
index 881e59e3f..8efe155b9 100644
--- a/pp/primitives/hash.h
+++ b/pp/primitives/hash.h
@@ -6,7 +6,7 @@ namespace PromPP::Primitives::hash {
 
 template <class LabelSet>
 size_t hash_of_label_set(const LabelSet& label_set) noexcept {
-  BareBones::XXHash hash;
+  BareBones::XXHash3 hash;
   for (const auto& [label_name, label_value] : label_set) {
     hash.extend(static_cast<std::string_view>(label_name), static_cast<std::string_view>(label_value));
   }
@@ -15,7 +15,7 @@ size_t hash_of_label_set(const LabelSet& label_set) noexcept {
 
 template <class StringList>
 size_t hash_of_string_list(const StringList& strings) noexcept {
-  BareBones::XXHash hash;
+  BareBones::XXHash3 hash;
   for (const auto& string : strings) {
     hash.extend(static_cast<std::string_view>(string));
   }
diff --git a/pp/primitives/label_set.h b/pp/primitives/label_set.h
index cfbf75fe9..aa0e90f90 100644
--- a/pp/primitives/label_set.h
+++ b/pp/primitives/label_set.h
@@ -6,6 +6,9 @@
 #include "primitives.h"
 
 namespace PromPP::Primitives {
+
+struct NoSortLabels {};
+
 template <class LabelType, template <class> class Container = BareBones::Vector>
 class BasicLabelSet {
  public:
@@ -30,7 +33,16 @@ class BasicLabelSet {
       }
       labels_.emplace_back(label);
     }
-  };
+  }
+
+  template <class LabelSet>
+  explicit BasicLabelSet(const LabelSet& other, const NoSortLabels&) {
+    labels_.reserve(other.size());
+
+    for (const auto& label : other) {
+      append(static_cast<std::string_view>(label.first), static_cast<std::string_view>(label.second));
+    }
+  }
 
   BasicLabelSet(const BasicLabelSet&) = default;
   BasicLabelSet(BasicLabelSet&&) noexcept = default;
diff --git a/pp/primitives/tests/go_metric_tests.cpp b/pp/primitives/tests/go_metric_tests.cpp
new file mode 100644
index 000000000..d8c4ccc79
--- /dev/null
+++ b/pp/primitives/tests/go_metric_tests.cpp
@@ -0,0 +1,43 @@
+#include <gtest/gtest.h>
+
+#include "primitives/go_metric.h"
+
+namespace {
+
+using PromPP::Primitives::LabelView;
+using PromPP::Primitives::Go::String;
+using PromPP::Primitives::Go::dto::LabelPair;
+using PromPP::Primitives::Go::dto::LabelPairsList;
+using PromPP::Primitives::Go::dto::MetricDescriptor;
+
+class MetricDescriptorFixture : public testing::Test {};
+
+TEST_F(MetricDescriptorFixture, TestWithEmptyLabels) {
+  // Arrange
+  constexpr LabelPairsList labels;
+
+  // Act
+  const MetricDescriptor descriptor(String("metric_name"), labels);
+
+  // Assert
+  EXPECT_EQ(10848170393603132573ULL, descriptor.id);
+  EXPECT_EQ(10764519495013463364ULL, descriptor.dim_hash);
+}
+
+TEST_F(MetricDescriptorFixture, TestWithLabels) {
+  // Arrange
+  constexpr String name1{"name1"};
+  constexpr String value1{"value1"};
+  constexpr String name2{"name2"};
+  constexpr String value2{"value2"};
+  const LabelPairsList labels{LabelPair{&name2, &value2}, LabelPair{&name1, &value1}};
+
+  // Act
+  const MetricDescriptor descriptor(String("metric_name"), labels);
+
+  // Assert
+  EXPECT_EQ(9433770049495071547ULL, descriptor.id);
+  EXPECT_EQ(1413792954011449091ULL, descriptor.dim_hash);
+}
+
+}  // namespace
\ No newline at end of file
diff --git a/pp/wal/hashdex/scraper/scraper.h b/pp/wal/hashdex/scraper/scraper.h
index 6f9b2db5f..b3538c59c 100644
--- a/pp/wal/hashdex/scraper/scraper.h
+++ b/pp/wal/hashdex/scraper/scraper.h
@@ -343,7 +343,7 @@ class Scraper {
 
   void append_labels_hash() noexcept {
     const auto& tokenizer = parser_.tokenizer();
-    BareBones::XXHash hash;
+    BareBones::XXHash3 hash;
     for (const auto& label : labels_) {
       hash.extend(label.name.view(tokenizer.buffer()), label.value.view(tokenizer.buffer()));
     }