From 2a549af46f3cc4f4b6f3737c292a534ca3cc389c Mon Sep 17 00:00:00 2001
From: Teddy Astie <teddy.astie@vates.tech>
Date: Mon, 6 Jan 2025 14:27:29 +0100
Subject: [PATCH] Reorganize xcp-metrics/xcp-metrics-common

Remove protocol v3 replaced by newer "xcp-metrics protocol v1".
Remove XAPI RPC.
Remove xcp-rrdd compatibility layers.
Only support "xcp-metrics protocol" for plugins/daemon communication.
---
 xcp-metrics-common/Cargo.toml                 |  40 ++-
 xcp-metrics-common/build.rs                   |   1 +
 xcp-metrics-common/src/lib.rs                 |   7 +-
 xcp-metrics-common/src/metrics.rs             |  48 ++-
 xcp-metrics-common/src/openmetrics/convert.rs |  58 ++--
 xcp-metrics-common/src/openmetrics/test.rs    | 155 ++++-----
 xcp-metrics-common/src/openmetrics/text.rs    | 192 +++++------
 xcp-metrics-common/src/protocol.rs            | 170 +++++++++
 xcp-metrics-common/src/protocol_v3.rs         | 236 -------------
 xcp-metrics-common/src/rrdd/mod.rs            |   1 -
 .../src/rrdd/protocol_common.rs               |  33 +-
 xcp-metrics-common/src/rrdd/rrd_updates.rs    | 157 ---------
 xcp-metrics-common/src/test.rs                | 166 +--------
 xcp-metrics-common/src/utils/delta.rs         |   8 +-
 xcp-metrics-common/src/utils/mapping.rs       |  43 +--
 xcp-metrics-common/src/utils/mod.rs           |   1 +
 xcp-metrics/Cargo.toml                        |  26 +-
 xcp-metrics/src/forwarded/mod.rs              |  94 -----
 xcp-metrics/src/forwarded/request.rs          |  89 -----
 xcp-metrics/src/forwarded/response.rs         |  48 ---
 xcp-metrics/src/forwarded/routes.rs           |  97 ------
 xcp-metrics/src/hub.rs                        | 190 +++++-----
 xcp-metrics/src/main.rs                       | 102 +-----
 xcp-metrics/src/mappings.rs                   |  34 --
 xcp-metrics/src/providers/mod.rs              |  11 -
 xcp-metrics/src/providers/protocol_v2.rs      | 254 --------------
 xcp-metrics/src/providers/protocol_v3.rs      | 132 -------
 xcp-metrics/src/publishers/mod.rs             |   3 -
 xcp-metrics/src/publishers/openmetrics.rs     |  69 ----
 xcp-metrics/src/publishers/rrdd/entry.rs      |  60 ----
 xcp-metrics/src/publishers/rrdd/mod.rs        |  88 -----
 .../src/publishers/rrdd/round_robin.rs        | 184 ----------
 xcp-metrics/src/publishers/rrdd/server.rs     | 324 ------------------
 xcp-metrics/src/rpc.rs                        |  81 +++++
 xcp-metrics/src/rpc/mod.rs                    | 103 ------
 xcp-metrics/src/rpc/routes/deregister.rs      |  28 --
 xcp-metrics/src/rpc/routes/get_formats.rs     |  22 --
 xcp-metrics/src/rpc/routes/mod.rs             |  50 ---
 xcp-metrics/src/rpc/routes/next_reading.rs    |  19 -
 xcp-metrics/src/rpc/routes/register.rs        |  66 ----
 xcp-metrics/src/rpc/routes/register_v3.rs     |  54 ---
 41 files changed, 647 insertions(+), 2897 deletions(-)
 create mode 100644 xcp-metrics-common/src/protocol.rs
 delete mode 100644 xcp-metrics-common/src/protocol_v3.rs
 delete mode 100644 xcp-metrics-common/src/rrdd/rrd_updates.rs
 delete mode 100644 xcp-metrics/src/forwarded/mod.rs
 delete mode 100644 xcp-metrics/src/forwarded/request.rs
 delete mode 100644 xcp-metrics/src/forwarded/response.rs
 delete mode 100644 xcp-metrics/src/forwarded/routes.rs
 delete mode 100644 xcp-metrics/src/mappings.rs
 delete mode 100644 xcp-metrics/src/providers/mod.rs
 delete mode 100644 xcp-metrics/src/providers/protocol_v2.rs
 delete mode 100644 xcp-metrics/src/providers/protocol_v3.rs
 delete mode 100644 xcp-metrics/src/publishers/mod.rs
 delete mode 100644 xcp-metrics/src/publishers/openmetrics.rs
 delete mode 100644 xcp-metrics/src/publishers/rrdd/entry.rs
 delete mode 100644 xcp-metrics/src/publishers/rrdd/mod.rs
 delete mode 100644 xcp-metrics/src/publishers/rrdd/round_robin.rs
 delete mode 100644 xcp-metrics/src/publishers/rrdd/server.rs
 create mode 100644 xcp-metrics/src/rpc.rs
 delete mode 100644 xcp-metrics/src/rpc/mod.rs
 delete mode 100644 xcp-metrics/src/rpc/routes/deregister.rs
 delete mode 100644 xcp-metrics/src/rpc/routes/get_formats.rs
 delete mode 100644 xcp-metrics/src/rpc/routes/mod.rs
 delete mode 100644 xcp-metrics/src/rpc/routes/next_reading.rs
 delete mode 100644 xcp-metrics/src/rpc/routes/register.rs
 delete mode 100644 xcp-metrics/src/rpc/routes/register_v3.rs

diff --git a/xcp-metrics-common/Cargo.toml b/xcp-metrics-common/Cargo.toml
index e24e956..99a9e38 100644
--- a/xcp-metrics-common/Cargo.toml
+++ b/xcp-metrics-common/Cargo.toml
@@ -9,13 +9,12 @@ rust-version = "1.70" # we need only 1.66 but our deps want 1.70
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-crc32fast = "1.4"
-serde_json = "1.0"
 anyhow = "1.0"
-prost = "0.13"
-prost-types = "0.13"
 maplit = "1.0"
-json5 = "0.4.1"
+smol_str = { version = "0.3", features = ["serde"] }
+
+# xcp-metrics protocol v1
+ciborium = "0.2"
 
 [dependencies.serde]
 version = "1.0"
@@ -25,19 +24,40 @@ features = ["std", "derive"]
 version = "1.11"
 features = ["std", "serde", "v4", "fast-rng"]
 
-[dependencies.indexmap]
-version = "2.7"
-features = ["serde"]
-
 [dependencies.tokio]
 version = "1"
 features = ["io-util"]
 
+# OpenMetrics support
+[dependencies.prost]
+version = "0.13"
+optional = true
+
+[dependencies.prost-types]
+version = "0.13"
+optional = true
+
+# RRDD Compatibility dependencies
+[dependencies.crc32fast]
+version = "1.4"
+optional = true
+
+[dependencies.serde_json]
+version = "1.0"
+optional = true
+
+[dependencies.indexmap]
+version = "2.7"
+features = ["serde"]
+optional = true
+
 [build-dependencies]
-prost-build = "0.13"
+prost-build = { version = "0.13", optional = true }
 
 [features]
 default = []
+rrdd_compat = ["dep:crc32fast", "dep:serde_json", "dep:indexmap"]
+openmetrics = ["dep:prost", "dep:prost-types", "dep:prost-build"]
 test = ["tokio/full"]
 
 [dev-dependencies]
diff --git a/xcp-metrics-common/build.rs b/xcp-metrics-common/build.rs
index 5fc717a..11c53f4 100644
--- a/xcp-metrics-common/build.rs
+++ b/xcp-metrics-common/build.rs
@@ -1,3 +1,4 @@
 fn main() {
+    #[cfg(feature = "openmetrics")]
     prost_build::compile_protos(&["src/openmetrics_data_model.proto"], &["src/"]).unwrap();
 }
diff --git a/xcp-metrics-common/src/lib.rs b/xcp-metrics-common/src/lib.rs
index c73ba0c..b81177e 100644
--- a/xcp-metrics-common/src/lib.rs
+++ b/xcp-metrics-common/src/lib.rs
@@ -1,9 +1,12 @@
 //! xcp-metrics common library
 pub mod metrics;
+pub mod protocol;
+pub mod utils;
+
+#[cfg(feature = "openmetrics")]
 pub mod openmetrics;
-pub mod protocol_v3;
+#[cfg(feature = "rrdd_compat")]
 pub mod rrdd;
-pub mod utils;
 
 #[cfg(test)]
 mod test;
diff --git a/xcp-metrics-common/src/metrics.rs b/xcp-metrics-common/src/metrics.rs
index b252eb2..2edf4cc 100644
--- a/xcp-metrics-common/src/metrics.rs
+++ b/xcp-metrics-common/src/metrics.rs
@@ -1,23 +1,28 @@
 //! Common metrics data structures, mostly modelled after OpenMetrics.
 use std::{collections::HashMap, time::SystemTime};
 
+use serde::{Deserialize, Serialize};
+use smol_str::SmolStr;
+
 /// Top level metric data structure.
 #[derive(Clone, Default, PartialEq, Debug)]
 pub struct MetricSet {
-    pub families: HashMap<Box<str>, MetricFamily>,
+    pub families: HashMap<SmolStr, MetricFamily>,
 }
 
 /// A family of [Metric] sharing a [MetricType] and `unit`.
 #[derive(Clone, Default, PartialEq, Debug)]
 pub struct MetricFamily {
+    // Number of references to this family.
+    pub reference_count: usize,
     pub metric_type: MetricType,
-    pub unit: Box<str>,
-    pub help: Box<str>,
+    pub unit: SmolStr,
+    pub help: SmolStr,
 
     pub metrics: HashMap<uuid::Uuid, Metric>,
 }
 
-#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]
+#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug, Serialize, Deserialize)]
 pub enum MetricType {
     #[default]
     Unknown,
@@ -45,28 +50,19 @@ impl std::fmt::Display for MetricType {
     }
 }
 
-#[derive(Clone, PartialEq, Debug, Eq, Hash)]
-pub struct Label(
-    /// Label name
-    pub Box<str>,
-    /// Label value
-    pub Box<str>,
-);
+#[derive(Clone, PartialEq, Debug, Eq, Hash, Serialize, Deserialize)]
+pub struct Label {
+    pub name: SmolStr,
+    pub value: SmolStr,
+}
 
-#[derive(Clone, Default, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
 pub struct Metric {
     pub labels: Box<[Label]>,
-    pub metrics_point: Box<[MetricPoint]>,
-}
-
-#[derive(Clone, PartialEq, Debug)]
-pub struct MetricPoint {
-    /// *Its type should match with MetricFamily's MetricType for text export.*
     pub value: MetricValue,
-    pub timestamp: SystemTime,
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
 pub enum MetricValue {
     Unknown(NumberValue),
     Gauge(NumberValue),
@@ -105,33 +101,33 @@ impl MetricValue {
     }
 }
 
-#[derive(Clone, Default, PartialEq, Debug)]
+#[derive(Clone, Default, PartialEq, Debug, Serialize, Deserialize)]
 pub struct Bucket {
     pub count: u64,
     pub upper_bound: f64,
     pub exemplar: Option<Box<Exemplar>>,
 }
 
-#[derive(Clone, Default, PartialEq, Debug)]
+#[derive(Clone, Default, PartialEq, Debug, Serialize, Deserialize)]
 pub struct Exemplar {
     pub value: f64,
     pub timestamp: Option<SystemTime>,
     pub labels: Box<[Label]>,
 }
 
-#[derive(Clone, Default, PartialEq, Debug)]
+#[derive(Clone, Default, PartialEq, Debug, Serialize, Deserialize)]
 pub struct State {
     pub enabled: bool,
-    pub name: Box<str>,
+    pub name: SmolStr,
 }
 
-#[derive(Clone, Copy, Default, PartialEq, Debug)]
+#[derive(Clone, Copy, Default, PartialEq, Debug, Serialize, Deserialize)]
 pub struct Quantile {
     pub quantile: f64,
     pub value: f64,
 }
 
-#[derive(Clone, Copy, Default, PartialEq, Debug)]
+#[derive(Clone, Copy, Default, PartialEq, Debug, Serialize, Deserialize)]
 pub enum NumberValue {
     Double(f64),
     Int64(i64),
diff --git a/xcp-metrics-common/src/openmetrics/convert.rs b/xcp-metrics-common/src/openmetrics/convert.rs
index 74aa1cd..4b9e195 100644
--- a/xcp-metrics-common/src/openmetrics/convert.rs
+++ b/xcp-metrics-common/src/openmetrics/convert.rs
@@ -3,8 +3,8 @@
 use std::time::SystemTime;
 
 use crate::metrics::{
-    Bucket, Exemplar, Label, Metric, MetricFamily, MetricPoint, MetricSet, MetricType, MetricValue,
-    NumberValue, Quantile, State,
+    Bucket, Exemplar, Label, Metric, MetricFamily, MetricSet, MetricType, MetricValue, NumberValue,
+    Quantile, State,
 };
 
 use super::{
@@ -59,17 +59,20 @@ impl From<openmetrics::MetricType> for MetricType {
 
 /// Convert a [Label] into a [openmetrics::Label].
 impl From<Label> for openmetrics::Label {
-    fn from(Label(name, value): Label) -> Self {
+    fn from(Label { name, value }: Label) -> Self {
         Self {
-            name: name.into_string(),
-            value: value.into_string(),
+            name: name.to_string(),
+            value: value.to_string(),
         }
     }
 }
 
 impl From<openmetrics::Label> for Label {
     fn from(value: openmetrics::Label) -> Self {
-        Self(value.name.into_boxed_str(), value.value.into_boxed_str())
+        Self {
+            name: value.name.into(),
+            value: value.value.into(),
+        }
     }
 }
 
@@ -230,7 +233,7 @@ impl From<State> for openmetrics::state_set_value::State {
     fn from(State { enabled, name }: State) -> Self {
         Self {
             enabled,
-            name: name.into_string(),
+            name: name.to_string(),
         }
     }
 }
@@ -241,7 +244,7 @@ impl From<openmetrics::state_set_value::State> for State {
     ) -> Self {
         Self {
             enabled,
-            name: name.into_boxed_str(),
+            name: name.into(),
         }
     }
 }
@@ -360,39 +363,27 @@ impl From<openmetrics::metric_point::Value> for MetricValue {
     }
 }
 
-impl From<MetricPoint> for openmetrics::MetricPoint {
-    fn from(MetricPoint { value, timestamp }: MetricPoint) -> Self {
+impl From<MetricValue> for openmetrics::MetricPoint {
+    fn from(value: MetricValue) -> Self {
         Self {
             value: Some(value.into()),
-            timestamp: Some(timestamp.into()),
+            timestamp: None,
         }
     }
 }
 
-impl From<openmetrics::MetricPoint> for MetricPoint {
-    fn from(openmetrics::MetricPoint { value, timestamp }: openmetrics::MetricPoint) -> Self {
-        Self {
-            value: value.map_or(MetricValue::Unknown(NumberValue::Undefined), Into::into),
-            timestamp: timestamp.map_or_else(SystemTime::now, protobuf_ts_to_std),
-        }
+impl From<openmetrics::MetricPoint> for MetricValue {
+    fn from(openmetrics::MetricPoint { value, .. }: openmetrics::MetricPoint) -> Self {
+        value.map_or(MetricValue::Unknown(NumberValue::Undefined), Into::into)
     }
 }
 
 /// Convert a [Metric] to a [openmetrics::Metric].
 impl From<Metric> for openmetrics::Metric {
-    fn from(
-        Metric {
-            labels,
-            metrics_point,
-        }: Metric,
-    ) -> Self {
+    fn from(Metric { labels, value }: Metric) -> Self {
         Self {
             labels: labels.into_vec().into_iter().map(Into::into).collect(),
-            metric_points: metrics_point
-                .into_vec()
-                .into_iter()
-                .map(Into::into)
-                .collect(),
+            metric_points: vec![value.into()],
         }
     }
 }
@@ -406,7 +397,7 @@ impl From<openmetrics::Metric> for Metric {
     ) -> Self {
         Self {
             labels: labels.into_iter().map(Into::into).collect(),
-            metrics_point: metric_points.into_iter().map(Into::into).collect(),
+            value: metric_points.first().cloned().unwrap_or_default().into(),
         }
     }
 }
@@ -418,9 +409,9 @@ impl From<MetricSet> for openmetrics::MetricSet {
             metric_families: families
                 .into_iter()
                 .map(|(name, family)| openmetrics::MetricFamily {
-                    name: name.into_string(),
-                    help: family.help.into_string(),
-                    unit: family.unit.into_string(),
+                    name: name.into(),
+                    help: family.help.into(),
+                    unit: family.unit.into(),
                     r#type: openmetrics::MetricType::from(family.metric_type).into(),
                     metrics: family
                         .metrics
@@ -441,8 +432,9 @@ impl From<openmetrics::MetricSet> for MetricSet {
                 .into_iter()
                 .map(|family| {
                     (
-                        family.name.into_boxed_str(),
+                        family.name.into(),
                         MetricFamily {
+                            reference_count: 1,
                             help: family.help.into(),
                             unit: family.unit.into(),
                             metric_type: openmetrics::MetricType::try_from(family.r#type)
diff --git a/xcp-metrics-common/src/openmetrics/test.rs b/xcp-metrics-common/src/openmetrics/test.rs
index 3383855..6735d77 100644
--- a/xcp-metrics-common/src/openmetrics/test.rs
+++ b/xcp-metrics-common/src/openmetrics/test.rs
@@ -1,22 +1,17 @@
 use std::time::{Duration, SystemTime};
 
-use crate::metrics::{
-    Bucket, Exemplar, Label, MetricPoint, MetricValue, NumberValue, Quantile, State,
-};
+use crate::metrics::{Bucket, Exemplar, Label, MetricValue, NumberValue, Quantile, State};
 
 use super::convert::openmetrics;
 
 /// Test conversions between xcp-metrics and OpenMetrics Gauge.
 #[test]
 fn metrics_to_openmetrics_gauge() {
-    let metric_point = MetricPoint {
-        value: MetricValue::Gauge(NumberValue::Int64(42)),
-        timestamp: SystemTime::now(),
-    };
+    let metric_point = MetricValue::Gauge(NumberValue::Int64(42));
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
@@ -24,18 +19,15 @@ fn metrics_to_openmetrics_gauge() {
 /// Test conversions between xcp-metrics and OpenMetrics Counter.
 #[test]
 fn metrics_to_openmetrics_counter() {
-    let metric_point = MetricPoint {
-        value: MetricValue::Counter {
-            total: NumberValue::Int64(42),
-            created: Some(SystemTime::UNIX_EPOCH + Duration::from_secs(123456789)),
-            exemplar: None,
-        },
-        timestamp: SystemTime::now(),
+    let metric_point = MetricValue::Counter {
+        total: NumberValue::Int64(42),
+        created: Some(SystemTime::UNIX_EPOCH + Duration::from_secs(123456789)),
+        exemplar: None,
     };
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
@@ -43,14 +35,17 @@ fn metrics_to_openmetrics_counter() {
 /// Test conversions between xcp-metrics and OpenMetrics Info.
 #[test]
 fn metrics_to_openmetrics_info() {
-    let metric_point = MetricPoint {
-        value: MetricValue::Info(vec![Label("a".into(), "b".into())].into()),
-        timestamp: SystemTime::now(),
-    };
+    let metric_point = MetricValue::Info(
+        vec![Label {
+            name: "a".into(),
+            value: "b".into(),
+        }]
+        .into(),
+    );
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
@@ -58,14 +53,11 @@ fn metrics_to_openmetrics_info() {
 /// Test conversions between xcp-metrics and OpenMetrics Unknown.
 #[test]
 fn metrics_to_openmetrics_unknown() {
-    let metric_point = MetricPoint {
-        value: MetricValue::Unknown(NumberValue::Int64(123)),
-        timestamp: SystemTime::now(),
-    };
+    let metric_point = MetricValue::Unknown(NumberValue::Int64(123));
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
@@ -73,26 +65,23 @@ fn metrics_to_openmetrics_unknown() {
 /// Test conversions between xcp-metrics and OpenMetrics StateSet.
 #[test]
 fn metrics_to_openmetrics_state_set() {
-    let metric_point = MetricPoint {
-        value: MetricValue::StateSet(
-            vec![
-                State {
-                    enabled: true,
-                    name: "A".into(),
-                },
-                State {
-                    enabled: false,
-                    name: "B".into(),
-                },
-            ]
-            .into(),
-        ),
-        timestamp: SystemTime::now(),
-    };
+    let metric_point = MetricValue::StateSet(
+        vec![
+            State {
+                enabled: true,
+                name: "A".into(),
+            },
+            State {
+                enabled: false,
+                name: "B".into(),
+            },
+        ]
+        .into(),
+    );
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
@@ -100,29 +89,26 @@ fn metrics_to_openmetrics_state_set() {
 /// Test conversions between xcp-metrics and OpenMetrics Summary.
 #[test]
 fn metrics_to_openmetrics_summary() {
-    let metric_point = MetricPoint {
-        value: MetricValue::Summary {
-            sum: NumberValue::Int64(1),
-            count: 2,
-            created: SystemTime::UNIX_EPOCH + Duration::from_secs(123456789),
-            quantile: vec![
-                Quantile {
-                    quantile: 1.0,
-                    value: 1.0,
-                },
-                Quantile {
-                    quantile: 2.0,
-                    value: 2.0,
-                },
-            ]
-            .into(),
-        },
-        timestamp: SystemTime::now(),
+    let metric_point = MetricValue::Summary {
+        sum: NumberValue::Int64(1),
+        count: 2,
+        created: SystemTime::UNIX_EPOCH + Duration::from_secs(123456789),
+        quantile: vec![
+            Quantile {
+                quantile: 1.0,
+                value: 1.0,
+            },
+            Quantile {
+                quantile: 2.0,
+                value: 2.0,
+            },
+        ]
+        .into(),
     };
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
@@ -134,36 +120,37 @@ fn metrics_to_openmetrics_histogram() {
         Exemplar {
             value: 1.0,
             timestamp: Some(SystemTime::UNIX_EPOCH + Duration::from_secs(123456789)),
-            labels: vec![Label("a".into(), "b".into())].into(),
+            labels: vec![Label {
+                name: "a".into(),
+                value: "b".into(),
+            }]
+            .into(),
         }
         .into(),
     );
 
-    let metric_point = MetricPoint {
-        value: MetricValue::Histogram {
-            sum: NumberValue::Int64(1),
-            count: 1,
-            created: SystemTime::UNIX_EPOCH + Duration::from_secs(123456789),
-            buckets: vec![
-                Bucket {
-                    count: 1,
-                    upper_bound: 1.0,
-                    exemplar: None,
-                },
-                Bucket {
-                    count: 1,
-                    upper_bound: 2.0,
-                    exemplar,
-                },
-            ]
-            .into(),
-        },
-        timestamp: SystemTime::now(),
+    let metric_point = MetricValue::Histogram {
+        sum: NumberValue::Int64(1),
+        count: 1,
+        created: SystemTime::UNIX_EPOCH + Duration::from_secs(123456789),
+        buckets: vec![
+            Bucket {
+                count: 1,
+                upper_bound: 1.0,
+                exemplar: None,
+            },
+            Bucket {
+                count: 1,
+                upper_bound: 2.0,
+                exemplar,
+            },
+        ]
+        .into(),
     };
 
     let om_metric_point = openmetrics::MetricPoint::from(metric_point.clone());
 
-    let decoded_metric_point = MetricPoint::from(om_metric_point);
+    let decoded_metric_point = MetricValue::from(om_metric_point);
 
     assert_eq!(metric_point, decoded_metric_point);
 }
diff --git a/xcp-metrics-common/src/openmetrics/text.rs b/xcp-metrics-common/src/openmetrics/text.rs
index ed22fa6..83619ad 100644
--- a/xcp-metrics-common/src/openmetrics/text.rs
+++ b/xcp-metrics-common/src/openmetrics/text.rs
@@ -114,7 +114,7 @@ fn format_label(name: &str, value: &str) -> String {
 fn format_labels(labels: &[Label]) -> String {
     labels
         .iter()
-        .map(|label| format_label(&label.0, &label.1))
+        .map(|label| format_label(&label.name, &label.value))
         .collect::<Vec<String>>() // TODO: Consider https://github.com/rust-lang/rust/issues/79524
         .join(",")
 }
@@ -136,124 +136,120 @@ fn format_exemplar(exemplar: Option<&Exemplar>) -> String {
 }
 
 fn write_metric<W: Write>(writer: &mut W, name: &str, metric: &Metric) -> Result<()> {
-    for metric_point in metric.metrics_point.iter() {
-        match &metric_point.value {
-            MetricValue::Unknown(value) | MetricValue::Gauge(value) => {
+    match &metric.value {
+        MetricValue::Unknown(value) | MetricValue::Gauge(value) => {
+            writeln!(
+                writer,
+                "{name}{{{}}} {}",
+                format_labels(&metric.labels),
+                format_number_value(value),
+            )?;
+        }
+        MetricValue::Counter {
+            total,
+            created,
+            exemplar,
+        } => {
+            writeln!(
+                writer,
+                "{name}_total{{{}}} {}{}",
+                format_labels(&metric.labels),
+                format_number_value(total),
+                format_exemplar(exemplar.as_deref())
+            )?;
+
+            if let Some(ts) = created {
                 writeln!(
                     writer,
-                    "{name}{{{}}} {}",
+                    "{name}_created{{{}}} {}",
                     format_labels(&metric.labels),
-                    format_number_value(value),
-                    // FIXME: timestamp breaks prometheus for some reason
-                    // format_timestamp(&metric_point.timestamp)
+                    format_timestamp(ts),
                 )?;
             }
-            MetricValue::Counter {
-                total,
-                created,
-                exemplar,
-            } => {
+        }
+        MetricValue::Histogram {
+            sum,
+            count,
+            created,
+            buckets,
+        } => {
+            let formatted_label = format_labels(&metric.labels);
+
+            for bucket in buckets.iter() {
                 writeln!(
                     writer,
-                    "{name}_total{{{}}} {}{}",
-                    format_labels(&metric.labels),
-                    format_number_value(total),
-                    format_exemplar(exemplar.as_deref())
+                    "{name}_bucket{{le=\"{}\"}} {}{}",
+                    bucket.upper_bound,
+                    bucket.count,
+                    format_exemplar(bucket.exemplar.as_deref())
                 )?;
-
-                if let Some(ts) = created {
-                    writeln!(
-                        writer,
-                        "{name}_created{{{}}} {}",
-                        format_labels(&metric.labels),
-                        format_timestamp(ts),
-                    )?;
-                }
             }
-            MetricValue::Histogram {
-                sum,
-                count,
-                created,
-                buckets,
-            } => {
-                let formatted_label = format_labels(&metric.labels);
-
-                for bucket in buckets.iter() {
-                    writeln!(
-                        writer,
-                        "{name}_bucket{{le=\"{}\"}} {}{}",
-                        bucket.upper_bound,
-                        bucket.count,
-                        format_exemplar(bucket.exemplar.as_deref())
-                    )?;
-                }
-
-                writeln!(writer, "{name}_count{{{formatted_label}}} {count}")?;
 
-                writeln!(
-                    writer,
-                    "{name}_sum{{{formatted_label}}} {}",
-                    format_number_value(sum)
-                )?;
+            writeln!(writer, "{name}_count{{{formatted_label}}} {count}")?;
+
+            writeln!(
+                writer,
+                "{name}_sum{{{formatted_label}}} {}",
+                format_number_value(sum)
+            )?;
+
+            writeln!(
+                writer,
+                "{name}_created{{{formatted_label}}} {}",
+                format_timestamp(created)
+            )?;
+        }
+        MetricValue::StateSet(states) => {
+            let formatted_labels = format_labels(&metric.labels);
 
+            for state in states.iter() {
                 writeln!(
                     writer,
-                    "{name}_created{{{formatted_label}}} {}",
-                    format_timestamp(created)
+                    "{name}{{{formatted_labels}{}{}}} {}",
+                    if metric.labels.is_empty() { "" } else { "," },
+                    format_label(name, &state.name),
+                    u32::from(state.enabled)
                 )?;
             }
-            MetricValue::StateSet(states) => {
-                let formatted_labels = format_labels(&metric.labels);
-
-                for state in states.iter() {
-                    writeln!(
-                        writer,
-                        "{name}{{{formatted_labels}{}{}}} {}",
-                        if metric.labels.is_empty() { "" } else { "," },
-                        format_label(name, &state.name),
-                        u32::from(state.enabled)
-                    )?;
-                }
-            }
-            MetricValue::Info(labels) => {
+        }
+        MetricValue::Info(labels) => {
+            writeln!(
+                writer,
+                "{name}_info{{{}{}{}}} 1",
+                format_labels(&metric.labels),
+                if metric.labels.is_empty() { "" } else { "," },
+                format_labels(labels)
+            )?;
+        }
+        MetricValue::Summary {
+            sum,
+            count,
+            created,
+            quantile,
+        } => {
+            let formatted_label = format_labels(&metric.labels);
+
+            for quantile in quantile.iter() {
                 writeln!(
                     writer,
-                    "{name}_info{{{}{}{}}} 1",
-                    format_labels(&metric.labels),
-                    if metric.labels.is_empty() { "" } else { "," },
-                    format_labels(labels)
+                    "{name}_bucket{{quantile=\"{}\"}} {}",
+                    quantile.quantile, quantile.value
                 )?;
             }
-            MetricValue::Summary {
-                sum,
-                count,
-                created,
-                quantile,
-            } => {
-                let formatted_label = format_labels(&metric.labels);
-
-                for quantile in quantile.iter() {
-                    writeln!(
-                        writer,
-                        "{name}_bucket{{quantile=\"{}\"}} {}",
-                        quantile.quantile, quantile.value
-                    )?;
-                }
-
-                writeln!(writer, "{name}_count{{{formatted_label}}} {count}")?;
 
-                writeln!(
-                    writer,
-                    "{name}_sum{{{formatted_label}}} {}",
-                    format_number_value(sum)
-                )?;
+            writeln!(writer, "{name}_count{{{formatted_label}}} {count}")?;
 
-                writeln!(
-                    writer,
-                    "{name}_created{{{formatted_label}}} {}",
-                    format_timestamp(created)
-                )?;
-            }
+            writeln!(
+                writer,
+                "{name}_sum{{{formatted_label}}} {}",
+                format_number_value(sum)
+            )?;
+
+            writeln!(
+                writer,
+                "{name}_created{{{formatted_label}}} {}",
+                format_timestamp(created)
+            )?;
         }
     }
 
diff --git a/xcp-metrics-common/src/protocol.rs b/xcp-metrics-common/src/protocol.rs
new file mode 100644
index 0000000..4f0da8f
--- /dev/null
+++ b/xcp-metrics-common/src/protocol.rs
@@ -0,0 +1,170 @@
+//! xcp-metrics protocol v4 implementation.
+//!
+//! Unix Domain Socket-based protocol based on CBOR.
+//! All CBOR payloads are prefixed with a 4-bytes big-endian length prefix.
+//!
+//! TODO: Protocol negociation
+use std::io::{self, Read, Write};
+
+use serde::{Deserialize, Serialize};
+use smol_str::SmolStr;
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+
+use crate::metrics::{Metric, MetricType};
+
+pub const METRICS_SOCKET_PATH: &str = "/var/lib/xcp/xcp-metrics";
+pub const MAX_PAYLOAD_SIZE: u32 = 512 * 1024; // 512 Ko
+
+/// Register a new metric family to the hub.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CreateFamily {
+    pub name: SmolStr,
+    pub metric_type: MetricType,
+    pub unit: SmolStr,
+    pub help: SmolStr,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Remove a metric family.
+pub struct RemoveFamily {
+    pub name: SmolStr,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Replace the values of a metric.
+pub struct UpdateMetric {
+    pub family_name: SmolStr,
+    pub metric: Metric,
+    pub uuid: uuid::Uuid,
+}
+
+/// Remove a metric from the hub.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RemoveMetric {
+    pub family_name: SmolStr,
+    pub uuid: uuid::Uuid,
+}
+
+/// Fetch metrics from xcp-metrics.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FetchMetrics {
+    /// OpenMetrics v1.0.0
+    OpenMetrics1,
+    /// OpenMetrics v1.0.0 (Protocol Buffers)
+    OpenMetrics1Binary,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ProtocolMessage {
+    CreateFamily(CreateFamily),
+    RemoveFamily(RemoveFamily),
+    UpdateMetric(UpdateMetric),
+    RemoveMetric(RemoveMetric),
+
+    FetchMetrics(FetchMetrics),
+}
+
+pub trait XcpMetricsStream {
+    fn send_message_raw(&mut self, message: &[u8]) -> io::Result<()>;
+
+    fn send_message(&mut self, message: ProtocolMessage) -> io::Result<()> {
+        let mut buffer = vec![];
+        ciborium::into_writer(&message, &mut buffer)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
+
+        self.send_message_raw(&buffer)
+    }
+
+    fn recv_message_raw(&mut self) -> io::Result<Box<[u8]>>;
+
+    fn recv_message(&mut self) -> io::Result<ProtocolMessage> {
+        let buffer = self.recv_message_raw()?;
+
+        Ok(ciborium::from_reader(buffer.as_ref())
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?)
+    }
+}
+
+impl<S> XcpMetricsStream for S
+where
+    S: Read + Write,
+{
+    fn send_message_raw(&mut self, message: &[u8]) -> io::Result<()> {
+        self.write_all(&(message.len() as u32).to_be_bytes())?;
+        self.write_all(&message)?;
+
+        Ok(())
+    }
+
+    fn recv_message_raw(&mut self) -> io::Result<Box<[u8]>> {
+        let mut prefix = [0u8; 4];
+        self.read_exact(&mut prefix)?;
+
+        let len = u32::from_be_bytes(prefix);
+
+        if len > MAX_PAYLOAD_SIZE {
+            return Err(io::Error::new(
+                io::ErrorKind::FileTooLarge,
+                "Payload is too large !",
+            ));
+        }
+
+        let mut buffer = vec![0u8; len as usize].into_boxed_slice();
+        self.read_exact(&mut buffer)?;
+
+        Ok(buffer)
+    }
+}
+
+#[allow(async_fn_in_trait)]
+pub trait XcpMetricsAsyncStream {
+    async fn send_message_raw_async(&mut self, message: &[u8]) -> io::Result<()>;
+
+    async fn send_message_async(&mut self, message: ProtocolMessage) -> io::Result<()> {
+        let mut buffer = vec![];
+        ciborium::into_writer(&message, &mut buffer)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
+
+        self.send_message_raw_async(&buffer).await
+    }
+
+    async fn recv_message_raw_async(&mut self) -> io::Result<Box<[u8]>>;
+
+    async fn recv_message_async(&mut self) -> io::Result<ProtocolMessage> {
+        let buffer = self.recv_message_raw_async().await?;
+
+        Ok(ciborium::from_reader(buffer.as_ref())
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?)
+    }
+}
+
+impl<S> XcpMetricsAsyncStream for S
+where
+    S: AsyncRead + AsyncWrite + Unpin,
+{
+    async fn send_message_raw_async(&mut self, message: &[u8]) -> io::Result<()> {
+        self.write_u32(message.len() as u32).await?;
+        self.write_all(&message).await?;
+
+        Ok(())
+    }
+
+    async fn recv_message_raw_async(&mut self) -> io::Result<Box<[u8]>> {
+        let mut prefix = [0u8; 4];
+        self.read_exact(&mut prefix).await?;
+
+        let len = u32::from_be_bytes(prefix);
+
+        if len > MAX_PAYLOAD_SIZE {
+            return Err(io::Error::new(
+                io::ErrorKind::FileTooLarge,
+                "Payload is too large !",
+            ));
+        }
+
+        let mut buffer = vec![0u8; len as usize].into_boxed_slice();
+        self.read_exact(&mut buffer).await?;
+
+        Ok(buffer)
+    }
+}
diff --git a/xcp-metrics-common/src/protocol_v3.rs b/xcp-metrics-common/src/protocol_v3.rs
deleted file mode 100644
index adce06e..0000000
--- a/xcp-metrics-common/src/protocol_v3.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-//! xcp-metrics protocol v3 implementation.
-//!
-//! For reference : <https://github.com/xapi-project/xapi-project.github.io/pull/278>
-
-use std::{
-    io::{self, Read, Write},
-    time::{self, Duration, SystemTime},
-};
-
-use crc32fast::Hasher;
-use prost::Message;
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite};
-
-use crate::{metrics::MetricSet, openmetrics};
-
-#[derive(Debug)]
-pub enum ProtocolV3Error {
-    IoError(io::Error),
-    InvalidHeader,
-    InvalidChecksum { got: u32, expected: u32 },
-    InvalidTimestamp,
-    OpenMetricsParseError(prost::DecodeError),
-    OpenMetricsEncodeError(prost::EncodeError),
-}
-
-impl From<io::Error> for ProtocolV3Error {
-    fn from(value: io::Error) -> Self {
-        Self::IoError(value)
-    }
-}
-
-impl From<prost::DecodeError> for ProtocolV3Error {
-    fn from(value: prost::DecodeError) -> Self {
-        Self::OpenMetricsParseError(value)
-    }
-}
-
-impl From<prost::EncodeError> for ProtocolV3Error {
-    fn from(value: prost::EncodeError) -> Self {
-        Self::OpenMetricsEncodeError(value)
-    }
-}
-
-impl std::fmt::Display for ProtocolV3Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ProtocolV3Error::IoError(err) => write!(f, "IO Error: {err}"),
-            ProtocolV3Error::InvalidHeader => write!(f, "Invalid header"),
-            ProtocolV3Error::InvalidChecksum { expected, got } => {
-                write!(f, "Invalid checksum (expected {expected}, got {got}")
-            }
-            ProtocolV3Error::InvalidTimestamp => write!(f, "Invalid timestamp"),
-            ProtocolV3Error::OpenMetricsParseError(err) => write!(f, "Payload parse error: {err}"),
-            ProtocolV3Error::OpenMetricsEncodeError(err) => {
-                write!(f, "Payload encoding error: {err}")
-            }
-        }
-    }
-}
-
-impl std::error::Error for ProtocolV3Error {}
-
-#[derive(Clone, Debug)]
-pub struct ProtocolV3Header {
-    pub data_checksum: u32,
-    pub timestamp: SystemTime,
-    pub payload_length: usize,
-    crc_state: Hasher,
-}
-
-pub const PROTOCOL_V3_HEADER: &[u8; 12] = b"OPENMETRICS1";
-
-impl ProtocolV3Header {
-    pub fn parse(raw_header: &[u8; 28]) -> Result<Self, ProtocolV3Error> {
-        if raw_header[0..12] != *PROTOCOL_V3_HEADER {
-            return Err(ProtocolV3Error::InvalidHeader);
-        }
-
-        let data_checksum = u32::from_be_bytes(raw_header[12..16].try_into().unwrap());
-        let timestamp_epoch = u64::from_be_bytes(raw_header[16..24].try_into().unwrap());
-        let payload_length = u32::from_be_bytes(raw_header[24..28].try_into().unwrap());
-
-        // Compute CRC for first part (from timstamp to the end of the header).
-        let mut crc_state = Hasher::new();
-        crc_state.update(&raw_header[16..]);
-
-        Ok(Self {
-            data_checksum,
-            timestamp: time::UNIX_EPOCH
-                .checked_add(Duration::from_secs(timestamp_epoch))
-                .ok_or(ProtocolV3Error::InvalidTimestamp)?,
-            payload_length: payload_length as usize,
-            crc_state,
-        })
-    }
-
-    pub fn parse_from<R: Read>(reader: &mut R) -> Result<Self, ProtocolV3Error> {
-        let mut raw_header: [u8; 28] = [0u8; 28];
-
-        reader.read_exact(&mut raw_header)?;
-
-        Self::parse(&raw_header)
-    }
-
-    pub async fn parse_async<R: Unpin + AsyncRead>(
-        reader: &mut R,
-    ) -> Result<Self, ProtocolV3Error> {
-        let mut raw_header: [u8; 28] = [0u8; 28];
-
-        tokio::io::AsyncReadExt::read_exact(reader, &mut raw_header).await?;
-
-        Self::parse(&raw_header)
-    }
-
-    /// Build a protocol v3 message for `payload_raw`.
-    pub fn generate(payload_raw: &[u8], timestamp: Option<SystemTime>) -> [u8; 28] {
-        // Build the payload in a buffer, and return it.
-
-        let mut buffer = [0u8; 28];
-        let mut writer = buffer.as_mut_slice();
-
-        writer.write_all(PROTOCOL_V3_HEADER).unwrap();
-
-        let timestamp = timestamp.unwrap_or_else(SystemTime::now);
-        let timestamp_epoch: u64 = timestamp
-            .duration_since(time::UNIX_EPOCH)
-            .expect("Non representable time encountered")
-            .as_secs();
-
-        let payload_length: u32 = payload_raw.len() as u32;
-
-        // data checksum is not yet computed, write 0 for now, we will replace it later.
-        writer.write_all(&0u32.to_be_bytes()).unwrap();
-
-        writer.write_all(&timestamp_epoch.to_be_bytes()).unwrap();
-        writer.write_all(&payload_length.to_be_bytes()).unwrap();
-
-        // Compute the checksum
-        let mut hasher = Hasher::new();
-        hasher.update(&buffer[16..]);
-        hasher.update(payload_raw);
-
-        let data_checksum: u32 = hasher.finalize();
-
-        // Replace the data checksum in place, writer cannot be used after this
-        buffer[12..16].copy_from_slice(&data_checksum.to_be_bytes());
-
-        buffer
-    }
-
-    pub fn check_payload(&self, payload: &[u8], final_checksum: &mut u32) -> bool {
-        let mut crc_state = self.crc_state.clone();
-        crc_state.update(payload);
-        *final_checksum = crc_state.finalize();
-
-        *final_checksum == self.data_checksum
-    }
-}
-
-pub fn parse_v3<R: Read>(reader: &mut R) -> Result<(ProtocolV3Header, MetricSet), ProtocolV3Error> {
-    let header = ProtocolV3Header::parse_from(reader)?;
-
-    let mut payload_data = vec![0u8; header.payload_length];
-    reader.read_exact(&mut payload_data)?;
-
-    // Check CRC32
-    let mut got = 0;
-
-    if !header.check_payload(&payload_data, &mut got) {
-        return Err(ProtocolV3Error::InvalidChecksum {
-            expected: header.data_checksum,
-            got,
-        });
-    }
-
-    Ok((
-        header,
-        openmetrics::MetricSet::decode(payload_data.as_slice())?.into(),
-    ))
-}
-
-pub async fn parse_v3_async<R: Unpin + AsyncRead>(
-    reader: &mut R,
-) -> Result<(ProtocolV3Header, MetricSet), ProtocolV3Error> {
-    let header = ProtocolV3Header::parse_async(reader).await?;
-
-    let mut payload_data = vec![0u8; header.payload_length];
-    reader.read_exact(&mut payload_data).await?;
-
-    // Check CRC32
-    let mut got = 0;
-
-    if !header.check_payload(&payload_data, &mut got) {
-        return Err(ProtocolV3Error::InvalidChecksum {
-            expected: header.data_checksum,
-            got,
-        });
-    }
-
-    Ok((
-        header,
-        openmetrics::MetricSet::decode(payload_data.as_slice())?.into(),
-    ))
-}
-
-pub fn generate_v3<W: Write>(
-    writer: &mut W,
-    timestamp: Option<SystemTime>,
-    metrics: MetricSet,
-) -> Result<(), ProtocolV3Error> {
-    let mut payload_raw = Vec::new();
-    openmetrics::MetricSet::from(metrics).encode(&mut payload_raw)?;
-
-    let header = ProtocolV3Header::generate(&payload_raw, timestamp);
-
-    writer.write_all(&header)?;
-    writer.write_all(&payload_raw)?;
-
-    Ok(())
-}
-
-pub async fn generate_v3_async<W: AsyncWrite + Unpin>(
-    writer: &mut W,
-    timestamp: Option<SystemTime>,
-    metrics: MetricSet,
-) -> Result<(), ProtocolV3Error> {
-    let mut payload_raw = Vec::new();
-    openmetrics::MetricSet::from(metrics).encode(&mut payload_raw)?;
-
-    let header = ProtocolV3Header::generate(&payload_raw, timestamp);
-
-    tokio::io::AsyncWriteExt::write_all(writer, &header).await?;
-    tokio::io::AsyncWriteExt::write_all(writer, &payload_raw).await?;
-
-    Ok(())
-}
diff --git a/xcp-metrics-common/src/rrdd/mod.rs b/xcp-metrics-common/src/rrdd/mod.rs
index 5474f72..1828ee3 100644
--- a/xcp-metrics-common/src/rrdd/mod.rs
+++ b/xcp-metrics-common/src/rrdd/mod.rs
@@ -2,7 +2,6 @@
 
 pub mod protocol_common;
 pub mod protocol_v2;
-pub mod rrd_updates;
 
 #[cfg(test)]
 mod test;
diff --git a/xcp-metrics-common/src/rrdd/protocol_common.rs b/xcp-metrics-common/src/rrdd/protocol_common.rs
index 38c45c6..062e936 100644
--- a/xcp-metrics-common/src/rrdd/protocol_common.rs
+++ b/xcp-metrics-common/src/rrdd/protocol_common.rs
@@ -2,9 +2,10 @@
 use std::{borrow::Cow, time::SystemTime};
 
 use serde::{de::Error, Deserialize, Serialize};
+use smol_str::{SmolStr, ToSmolStr};
 use uuid::Uuid;
 
-use crate::metrics::{Label, MetricPoint, MetricValue, NumberValue};
+use crate::metrics::{Label, MetricValue, NumberValue};
 
 /// Errors that can happen while parsing a data source.
 #[derive(Copy, Clone, Debug)]
@@ -181,8 +182,8 @@ pub struct DataSourceMetadataRaw {
 /// A metadata source.
 #[derive(Clone, PartialEq, Debug)]
 pub struct DataSourceMetadata {
-    pub description: Box<str>,
-    pub units: Box<str>,
+    pub description: SmolStr,
+    pub units: SmolStr,
     pub ds_type: DataSourceType,
     pub value: DataSourceValue,
     pub min: f32,
@@ -272,10 +273,10 @@ impl From<&DataSourceMetadata> for DataSourceMetadataRaw {
         let description = if val.description.is_empty() {
             None
         } else {
-            Some(val.description.as_ref().into())
+            Some(val.description.to_string())
         };
 
-        let units = Some(val.units.as_ref().into());
+        let units = Some(val.units.to_string());
 
         let ds_type = Some(<&str>::from(val.ds_type).to_string());
 
@@ -291,7 +292,7 @@ impl From<&DataSourceMetadata> for DataSourceMetadataRaw {
         let min = Some(val.min.to_string());
         let max = Some(val.max.to_string());
 
-        let owner = Some(<Box<str>>::from(val.owner).into_string());
+        let owner = Some(<Box<str>>::from(val.owner).into());
 
         Self {
             description,
@@ -326,37 +327,35 @@ impl crate::metrics::Metric {
     pub fn from_protocol_v2(
         metadata: &DataSourceMetadata,
         value: DataSourceValue,
-        timestamp: SystemTime,
         // Used for derive creation timestamp.
         created: Option<SystemTime>,
     ) -> Self {
-        let metric_point = MetricPoint::from_protocol_v2(metadata, value, timestamp, created);
-
         Self {
-            labels: vec![Label("owner".into(), metadata.owner.into())].into_boxed_slice(),
-            metrics_point: vec![metric_point].into_boxed_slice(),
+            labels: vec![Label {
+                name: "owner".into(),
+                value: <Box<str>>::from(metadata.owner).to_smolstr(),
+            }]
+            .into_boxed_slice(),
+            value: MetricValue::from_protocol_v2(metadata, value, created),
         }
     }
 }
 
-impl crate::metrics::MetricPoint {
+impl crate::metrics::MetricValue {
     pub fn from_protocol_v2(
         metadata: &DataSourceMetadata,
         value: DataSourceValue,
-        timestamp: SystemTime,
         // Used for derive creation timestamp.
         created: Option<SystemTime>,
     ) -> Self {
-        let value = match metadata.ds_type {
+        match metadata.ds_type {
             DataSourceType::Gauge => MetricValue::Gauge(value.into()),
             DataSourceType::Derive | DataSourceType::Absolute => MetricValue::Counter {
                 total: value.into(),
                 created,
                 exemplar: None,
             },
-        };
-
-        Self { timestamp, value }
+        }
     }
 }
 
diff --git a/xcp-metrics-common/src/rrdd/rrd_updates.rs b/xcp-metrics-common/src/rrdd/rrd_updates.rs
deleted file mode 100644
index 1f7a030..0000000
--- a/xcp-metrics-common/src/rrdd/rrd_updates.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-//! RRD Xport format and serialization.
-use std::{
-    fmt::Write,
-    time::{SystemTime, SystemTimeError},
-};
-
-use serde::Serialize;
-
-use crate::utils::write_bridge::WriterWrapper;
-
-#[derive(Debug, Clone)]
-pub struct RrdXport {
-    pub start: SystemTime,
-    pub end: SystemTime,
-    pub step_secs: u32,
-
-    pub legend: Vec<Box<str>>,
-    pub data: Vec<(SystemTime, Box<[f64]>)>,
-}
-
-impl RrdXport {
-    fn write_metadata_xml<W: std::io::Write>(&self, writer: &mut W) -> anyhow::Result<()> {
-        let writer = &mut WriterWrapper(writer);
-
-        write!(writer, "<meta>")?;
-
-        write!(
-            writer,
-            "<start>{}</start>",
-            self.start.duration_since(SystemTime::UNIX_EPOCH)?.as_secs()
-        )?;
-
-        write!(writer, "<step>{}</step>", self.step_secs)?;
-
-        write!(
-            writer,
-            "<end>{}</end>",
-            self.end.duration_since(SystemTime::UNIX_EPOCH)?.as_secs()
-        )?;
-
-        write!(writer, "<rows>{}</rows>", self.data.len())?;
-        write!(writer, "<columns>{}</columns>", self.legend.len())?;
-
-        write!(writer, "<legend>")?;
-        for entry in &self.legend {
-            write!(writer, "<entry>{entry}</entry>")?;
-        }
-        write!(writer, "</legend>")?;
-
-        write!(writer, "</meta>")?;
-
-        Ok(())
-    }
-
-    fn write_data_xml<W: std::io::Write>(&self, writer: &mut W) -> anyhow::Result<()> {
-        let writer = &mut WriterWrapper(writer);
-
-        write!(writer, "<data>")?;
-
-        for (t, values) in &self.data {
-            write!(
-                writer,
-                "<row><t>{}</t>",
-                t.duration_since(SystemTime::UNIX_EPOCH)?.as_secs()
-            )?;
-
-            for value in values.iter() {
-                write!(writer, "<v>{value}</v>")?;
-            }
-
-            write!(writer, "</row>")?;
-        }
-
-        write!(writer, "</data>")?;
-        Ok(())
-    }
-
-    pub fn write_xml<W: std::io::Write>(&self, writer: &mut W) -> anyhow::Result<()> {
-        let writer = &mut WriterWrapper(writer);
-
-        write!(writer, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>")?;
-        write!(writer, "<xport>")?;
-
-        self.write_metadata_xml(writer.0)?;
-        self.write_data_xml(writer.0)?;
-        write!(writer, "<script />")?;
-
-        write!(writer, "</xport>")?;
-
-        Ok(())
-    }
-}
-
-// JSON support
-
-#[derive(Serialize)]
-struct RrdXportJsonMeta<'a> {
-    start: u64,
-    step: u32,
-    end: u64,
-    rows: u32,
-    columns: u32,
-    legend: &'a [Box<str>],
-}
-
-#[derive(Serialize)]
-struct RrdXportJsonData<'a> {
-    timestamp: u64,
-    values: &'a [f64],
-}
-
-#[derive(Serialize)]
-struct RrdXportJson<'a> {
-    meta: RrdXportJsonMeta<'a>,
-    data: Vec<RrdXportJsonData<'a>>,
-}
-
-fn to_epoch(timestamp: SystemTime) -> Result<u64, SystemTimeError> {
-    Ok(timestamp.duration_since(SystemTime::UNIX_EPOCH)?.as_secs())
-}
-
-impl<'a> TryFrom<&'a RrdXport> for RrdXportJson<'a> {
-    type Error = SystemTimeError;
-
-    fn try_from(rrd: &'a RrdXport) -> Result<Self, Self::Error> {
-        Ok(Self {
-            meta: RrdXportJsonMeta {
-                start: to_epoch(rrd.start)?,
-                step: rrd.step_secs,
-                end: to_epoch(rrd.end)?,
-                rows: rrd.data.len() as _,
-                columns: rrd.legend.len() as _,
-                legend: &rrd.legend,
-            },
-            data: rrd
-                .data
-                .iter()
-                .map(|(timestamp, content)| {
-                    Ok(RrdXportJsonData {
-                        timestamp: to_epoch(*timestamp)?,
-                        values: content.as_ref(),
-                    })
-                })
-                .collect::<Result<_, _>>()?,
-        })
-    }
-}
-
-impl RrdXport {
-    pub fn to_json(&self) -> anyhow::Result<String> {
-        Ok(serde_json::to_string(&RrdXportJson::try_from(self)?)?)
-    }
-
-    pub fn to_json5(&self) -> anyhow::Result<String> {
-        Ok(json5::to_string(&RrdXportJson::try_from(self)?)?)
-    }
-}
diff --git a/xcp-metrics-common/src/test.rs b/xcp-metrics-common/src/test.rs
index 757c341..88e04d9 100644
--- a/xcp-metrics-common/src/test.rs
+++ b/xcp-metrics-common/src/test.rs
@@ -1,11 +1,9 @@
 //! Protocol v3 tests
 
-use std::{iter, time::SystemTime};
+use std::iter;
 
 use crate::{
-    metrics::{
-        Label, Metric, MetricFamily, MetricPoint, MetricSet, MetricType, MetricValue, NumberValue,
-    },
+    metrics::{Label, Metric, MetricFamily, MetricSet, MetricType, MetricValue, NumberValue},
     utils::delta::MetricSetModel,
 };
 
@@ -16,6 +14,7 @@ pub(crate) fn make_test_metrics_set() -> MetricSet {
             (
                 "test".into(),
                 MetricFamily {
+                    reference_count: 1,
                     metric_type: MetricType::Gauge,
                     unit: "unit".into(),
                     help: "help".into(),
@@ -23,23 +22,19 @@ pub(crate) fn make_test_metrics_set() -> MetricSet {
                         (
                             uuid::Uuid::new_v4(),
                             Metric {
-                                labels: vec![Label("test".into(), "test".into())].into(),
-                                metrics_point: vec![MetricPoint {
-                                    value: MetricValue::Gauge(NumberValue::Int64(1)),
-                                    timestamp: SystemTime::now(),
+                                labels: vec![Label {
+                                    name: "test".into(),
+                                    value: "test".into(),
                                 }]
                                 .into(),
+                                value: MetricValue::Gauge(NumberValue::Int64(1)),
                             },
                         ),
                         (
                             uuid::Uuid::new_v4(),
                             Metric {
                                 labels: vec![].into(),
-                                metrics_point: vec![MetricPoint {
-                                    value: MetricValue::Gauge(NumberValue::Int64(1)),
-                                    timestamp: SystemTime::now(),
-                                }]
-                                .into(),
+                                value: MetricValue::Gauge(NumberValue::Int64(1)),
                             },
                         ),
                     ]
@@ -50,22 +45,19 @@ pub(crate) fn make_test_metrics_set() -> MetricSet {
             (
                 "test2".into(),
                 MetricFamily {
+                    reference_count: 1,
                     metric_type: MetricType::Gauge,
                     unit: "unit".into(),
                     help: "help".into(),
                     metrics: [(
                         uuid::Uuid::new_v4(),
                         Metric {
-                            labels: vec![Label(
-                                "owner".into(),
-                                uuid::Uuid::new_v4().as_hyphenated().to_string().into(),
-                            )]
-                            .into(),
-                            metrics_point: vec![MetricPoint {
-                                value: MetricValue::Gauge(NumberValue::Int64(1)),
-                                timestamp: SystemTime::now(),
+                            labels: vec![Label {
+                                name: "owner".into(),
+                                value: uuid::Uuid::new_v4().as_hyphenated().to_string().into(),
                             }]
                             .into(),
+                            value: MetricValue::Gauge(NumberValue::Int64(1)),
                         },
                     )]
                     .into_iter()
@@ -75,6 +67,7 @@ pub(crate) fn make_test_metrics_set() -> MetricSet {
             (
                 "tes3".into(),
                 MetricFamily {
+                    reference_count: 1,
                     metric_type: MetricType::Gauge,
                     unit: "unit".into(),
                     help: "help".into(),
@@ -82,11 +75,7 @@ pub(crate) fn make_test_metrics_set() -> MetricSet {
                         uuid::Uuid::new_v4(),
                         Metric {
                             labels: vec![].into(),
-                            metrics_point: vec![MetricPoint {
-                                value: MetricValue::Gauge(NumberValue::Int64(1)),
-                                timestamp: SystemTime::now(),
-                            }]
-                            .into(),
+                            value: MetricValue::Gauge(NumberValue::Int64(1)),
                         },
                     )]
                     .into_iter()
@@ -123,128 +112,3 @@ fn assert_metrics_set_equals(a: &MetricSet, b: &MetricSet) {
             }
         })
 }
-
-mod protocol_v3 {
-    use std::time::{Duration, SystemTime};
-
-    use crate::protocol_v3::{
-        self, generate_v3, generate_v3_async, parse_v3, parse_v3_async, ProtocolV3Error,
-    };
-
-    use super::{assert_metrics_set_equals, make_test_metrics_set};
-
-    #[test]
-    fn header() {
-        let metrics_set = make_test_metrics_set();
-
-        // Generate raw payload.
-        let mut buffer = vec![];
-        generate_v3(&mut buffer, None, metrics_set.clone()).unwrap();
-
-        let (_, metrics_readed) = protocol_v3::parse_v3(&mut buffer.as_slice()).unwrap();
-
-        // We can't lazily compare them as xcp-metrics metrics has some additional informations
-        // (like internal uuid) that are randomly generated when parsing from OpenMetrics.
-
-        // Compare readed and original.
-        assert_metrics_set_equals(&metrics_set, &metrics_readed);
-    }
-
-    #[test]
-    fn invalid_header() {
-        // Empty header is invalid.
-        let invalid_header = [0u8; 28];
-
-        assert!(matches!(
-            parse_v3(&mut invalid_header.as_slice()),
-            Err(ProtocolV3Error::InvalidHeader)
-        ));
-    }
-
-    #[tokio::test]
-    async fn invalid_header_async() {
-        // Empty header is invalid.
-        let invalid_header = [0u8; 28];
-
-        assert!(matches!(
-            parse_v3_async(&mut invalid_header.as_slice()).await,
-            Err(ProtocolV3Error::InvalidHeader)
-        ));
-    }
-
-    #[test]
-    fn invalid_checksum() {
-        // Empty header is invalid.
-        let mut dest = vec![];
-
-        generate_v3(
-            &mut dest,
-            Some(SystemTime::UNIX_EPOCH + Duration::from_secs(123456789)),
-            crate::test::make_test_metrics_set(),
-        )
-        .unwrap();
-
-        // mess with dest checksum
-        dest.get_mut(12..16)
-            .unwrap()
-            .copy_from_slice(&[0xde, 0xad, 0xbe, 0xef]);
-
-        assert!(matches!(
-            parse_v3(&mut dest.as_slice()),
-            Err(ProtocolV3Error::InvalidChecksum { .. })
-        ));
-    }
-
-    #[tokio::test]
-    async fn invalid_checksum_async() {
-        // Empty header is invalid.
-        let mut dest = vec![];
-
-        generate_v3_async(
-            &mut dest,
-            Some(SystemTime::UNIX_EPOCH + Duration::from_secs(123456789)),
-            crate::test::make_test_metrics_set(),
-        )
-        .await
-        .unwrap();
-
-        // mess with dest checksum
-        dest.get_mut(12..16)
-            .unwrap()
-            .copy_from_slice(&[0xde, 0xad, 0xbe, 0xef]);
-
-        assert!(matches!(
-            parse_v3_async(&mut dest.as_slice()).await,
-            Err(ProtocolV3Error::InvalidChecksum { .. })
-        ));
-    }
-
-    #[test]
-    fn invalid_openmetrics() {
-        tokio::runtime::Builder::new_current_thread()
-            .build()
-            .unwrap()
-            .block_on(async {
-                // Empty header is invalid.
-                let mut dest = vec![];
-
-                generate_v3_async(
-                    &mut dest,
-                    Some(SystemTime::UNIX_EPOCH + Duration::from_secs(123456789)),
-                    crate::test::make_test_metrics_set(),
-                )
-                .await
-                .unwrap();
-
-                // mess with dest checksum
-                dest.get_mut(12..16)
-                    .unwrap()
-                    .copy_from_slice(&[0xde, 0xad, 0xbe, 0xef]);
-
-                assert!(matches!(
-                    parse_v3_async(&mut dest.as_slice()).await,
-                    Err(ProtocolV3Error::InvalidChecksum { .. })
-                ));
-            });
-    }
-}
diff --git a/xcp-metrics-common/src/utils/delta.rs b/xcp-metrics-common/src/utils/delta.rs
index 58dd791..573e88d 100644
--- a/xcp-metrics-common/src/utils/delta.rs
+++ b/xcp-metrics-common/src/utils/delta.rs
@@ -100,6 +100,8 @@ use std::{
     iter,
 };
 
+use smol_str::SmolStr;
+
 use crate::metrics::{Label, Metric, MetricFamily, MetricSet};
 
 /// Summary of changes between a MetricSetModel and a MetricSet (ignoring MetricSet UUIDs)
@@ -114,7 +116,7 @@ pub struct MetricSetDelta<'a> {
 
     /// Metrics that no longer contain a family.
     /// In case they reappears, they will need to be registered again.
-    pub orphaned_families: Vec<Box<str>>,
+    pub orphaned_families: Vec<SmolStr>,
 
     // Added metrics
     pub added_metrics: Vec<(&'a str, &'a Metric, uuid::Uuid)>,
@@ -134,8 +136,8 @@ pub struct MetricSetDelta<'a> {
 #[derive(Clone, Default, Debug, PartialEq)]
 pub struct MetricSetModel {
     /// Track metrics per family and labels set.
-    pub metrics_map: HashMap<(Box<str>, Box<[Label]>), uuid::Uuid>,
-    pub families: HashSet<Box<str>>,
+    pub metrics_map: HashMap<(SmolStr, Box<[Label]>), uuid::Uuid>,
+    pub families: HashSet<SmolStr>,
 }
 
 impl MetricSetModel {
diff --git a/xcp-metrics-common/src/utils/mapping.rs b/xcp-metrics-common/src/utils/mapping.rs
index 4c241fe..e14dc25 100644
--- a/xcp-metrics-common/src/utils/mapping.rs
+++ b/xcp-metrics-common/src/utils/mapping.rs
@@ -2,6 +2,7 @@
 use std::fmt::Write;
 
 use serde::{Deserialize, Serialize};
+use smol_str::SmolStr;
 
 use crate::{
     metrics::{Label, Metric, MetricFamily, MetricType, MetricValue, NumberValue},
@@ -15,7 +16,7 @@ pub trait MetadataMapping {
         family_name: &str,
         family: &MetricFamily,
         metric: &Metric,
-    ) -> Option<(Box<str>, DataSourceMetadata)>;
+    ) -> Option<(SmolStr, DataSourceMetadata)>;
 }
 
 #[derive(Clone, Copy, Debug, Default)]
@@ -27,12 +28,12 @@ impl MetadataMapping for DefaultMapping {
         family_name: &str,
         family: &MetricFamily,
         metric: &Metric,
-    ) -> Option<(Box<str>, DataSourceMetadata)> {
+    ) -> Option<(SmolStr, DataSourceMetadata)> {
         let owner = metric
             .labels
             .iter()
-            .filter(|l| l.0.as_ref() == "owner")
-            .map(|l| l.1.as_ref())
+            .filter(|l| l.name == "owner")
+            .map(|l| l.value.as_ref())
             .next()
             .unwrap_or("host");
 
@@ -43,9 +44,9 @@ impl MetadataMapping for DefaultMapping {
             .labels
             .iter()
             // Ignore owner label
-            .filter(|l| l.0.as_ref() != "owner")
+            .filter(|l| l.name != "owner")
             .fold(family_name.to_string(), |mut buffer, label| {
-                write!(buffer, "_{}", label.1).ok();
+                write!(buffer, "_{}", label.value).ok();
                 buffer
             });
 
@@ -55,22 +56,17 @@ impl MetadataMapping for DefaultMapping {
             _ => return None, /* Non-supported */
         };
 
-        let first_metric = metric
-            .metrics_point
-            .first()
-            .map(|metric_point| &metric_point.value);
-
-        let value = first_metric.map_or(DataSourceValue::Undefined, |metric| match metric {
+        let value = match metric.value {
             MetricValue::Gauge(value) | MetricValue::Counter { total: value, .. } => match value {
                 NumberValue::Double(_) => DataSourceValue::Float(0.0),
                 NumberValue::Int64(_) => DataSourceValue::Int64(0),
                 NumberValue::Undefined => DataSourceValue::Undefined,
             },
             _ => DataSourceValue::Undefined,
-        });
+        };
 
         Some((
-            name.into_boxed_str(),
+            name.into(),
             DataSourceMetadata {
                 description: family.help.clone(),
                 units: family.unit.clone(),
@@ -108,7 +104,7 @@ impl CustomMapping {
         let mut current = self.pattern.to_string();
 
         // Replace all occurences of `{label}` with its value.
-        metric.labels.iter().for_each(|Label(name, value)| {
+        metric.labels.iter().for_each(|Label { name, value }| {
             current = current.replace(format!("{{{name}}}").as_str(), value);
         });
 
@@ -122,19 +118,19 @@ impl MetadataMapping for CustomMapping {
         _: &str,
         family: &MetricFamily,
         metric: &Metric,
-    ) -> Option<(Box<str>, DataSourceMetadata)> {
+    ) -> Option<(SmolStr, DataSourceMetadata)> {
         let owner = metric
             .labels
             .iter()
-            .filter(|l| l.0.as_ref() == "owner")
-            .map(|l| l.1.as_ref())
+            .filter(|l| l.name == "owner")
+            .map(|l| l.value.as_ref())
             .next()
             .unwrap_or("host");
 
         // Parse owner
         let owner = DataSourceOwner::try_from(owner).unwrap_or(DataSourceOwner::Host);
 
-        let name = self.apply_pattern(metric);
+        let name = self.apply_pattern(metric).into();
 
         let ds_type = match family.metric_type {
             MetricType::Gauge => DataSourceType::Gauge,
@@ -142,19 +138,14 @@ impl MetadataMapping for CustomMapping {
             _ => return None, /* Non-supported */
         };
 
-        let first_metric = metric
-            .metrics_point
-            .first()
-            .map(|metric_point| &metric_point.value);
-
-        let value = first_metric.map_or(DataSourceValue::Undefined, |metric| match metric {
+        let value = match metric.value {
             MetricValue::Gauge(value) | MetricValue::Counter { total: value, .. } => match value {
                 NumberValue::Double(_) => DataSourceValue::Float(0.0),
                 NumberValue::Int64(_) => DataSourceValue::Int64(0),
                 NumberValue::Undefined => DataSourceValue::Undefined,
             },
             _ => DataSourceValue::Undefined,
-        });
+        };
 
         Some((
             name,
diff --git a/xcp-metrics-common/src/utils/mod.rs b/xcp-metrics-common/src/utils/mod.rs
index df84c7a..307480b 100644
--- a/xcp-metrics-common/src/utils/mod.rs
+++ b/xcp-metrics-common/src/utils/mod.rs
@@ -1,6 +1,7 @@
 //! Various xcp-metrics utilities.
 
 pub mod delta;
+#[cfg(feature = "rrdd_compat")]
 pub mod mapping;
 
 pub(crate) mod write_bridge;
diff --git a/xcp-metrics/Cargo.toml b/xcp-metrics/Cargo.toml
index acd8217..f8de6ec 100644
--- a/xcp-metrics/Cargo.toml
+++ b/xcp-metrics/Cargo.toml
@@ -8,32 +8,18 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-xcp-metrics-common = { path = "../xcp-metrics-common" }
-xapi = { path = "../xapi-rs", features = ["unix"] }
+xcp-metrics-common = { path = "../xcp-metrics-common", features = [
+  "openmetrics",
+] }
 
-http = "1.1"
-http-body = "1.0"
-http-body-util = "0.1"
-
-serde_json = "1.0"
 anyhow = "1.0"
 futures = "0.3"
-dashmap = "6.1"
 tracing = "0.1"
 tracing-subscriber = "0.3"
-maplit = "1.0.2"
-
-[dependencies.hyper]
-version = "1.5"
-features = ["http1", "server"]
-
-[dependencies.hyper-util]
-version = "0.1"
-features = ["service", "http1", "tokio"]
 
 [dependencies.tokio]
 version = "1"
-features = ["rt", "rt-multi-thread", "net", "fs", "macros"]
+features = ["rt", "rt-multi-thread", "net", "fs", "macros", "sync"]
 
 [dependencies.serde]
 version = "1.0"
@@ -43,10 +29,6 @@ features = ["std", "derive"]
 version = "1.4"
 features = ["std", "serde", "v4", "fast-rng"]
 
-[dependencies.sendfd]
-version = "0.4.3"
-features = ["tokio"]
-
 [dependencies.clap]
 version = "4.5"
 features = ["derive"]
diff --git a/xcp-metrics/src/forwarded/mod.rs b/xcp-metrics/src/forwarded/mod.rs
deleted file mode 100644
index 2c7e52c..0000000
--- a/xcp-metrics/src/forwarded/mod.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//! Forwarded request support.
-mod request;
-mod response;
-mod routes;
-
-use std::{
-    os::fd::{FromRawFd, RawFd},
-    path::Path,
-    slice,
-    sync::Arc,
-};
-
-use sendfd::RecvWithFd;
-use tokio::{
-    io::AsyncWriteExt,
-    net::{TcpStream, UnixListener, UnixStream},
-    task::{self, JoinHandle},
-};
-
-use crate::{
-    forwarded::{request::ForwardedRequest, routes::route_forwarded},
-    XcpMetricsShared,
-};
-
-async fn forwarded_handler(
-    stream: UnixStream,
-    shared: Arc<XcpMetricsShared>,
-) -> anyhow::Result<()> {
-    let (buffer, fd) = task::spawn_blocking(move || {
-        let mut buffer = vec![0u8; 10240];
-        let mut fd: RawFd = RawFd::default();
-
-        let std_stream = stream
-            .into_std()
-            .expect("Unable to convert tokio stream to std stream.");
-        let (readed, fds_count) = std_stream
-            .recv_with_fd(&mut buffer, slice::from_mut(&mut fd))
-            .expect("recv_with_fd failure");
-
-        assert_eq!(fds_count, 1, "fds_count is not 1");
-
-        buffer.resize(readed, 0);
-
-        (buffer.into_boxed_slice(), fd)
-    })
-    .await?;
-
-    // Get the fd from the forwarded response.
-    let std_destination = unsafe { std::net::TcpStream::from_raw_fd(fd) };
-    std_destination.set_nonblocking(true)?;
-
-    let mut destination = TcpStream::from_std(std_destination)?;
-
-    let request: ForwardedRequest = serde_json::from_slice(&buffer)?;
-    tracing::info!("Captured request: {request:?}");
-
-    let response = route_forwarded(shared.clone(), request).await;
-
-    let mut string: Vec<u8> = Vec::new();
-    response::write_response(&mut string, response?)
-        .await
-        .unwrap();
-
-    tracing::trace!(
-        "Sending request to socket:\n{}",
-        String::from_utf8_lossy(&string)
-    );
-
-    destination.write_all(&string).await.unwrap();
-
-    Ok(())
-}
-
-pub async fn start_forwarded_socket(
-    daemon_path: &Path,
-    shared: Arc<XcpMetricsShared>,
-) -> anyhow::Result<JoinHandle<()>> {
-    let daemon_path = daemon_path.to_path_buf();
-    let listener = UnixListener::bind(daemon_path)?;
-
-    tracing::info!("Starting forwarded");
-
-    Ok(task::spawn(async move {
-        while let Ok((stream, addr)) = listener.accept().await {
-            tracing::info!("Forwarded request from {addr:?}");
-
-            let shared = shared.clone();
-
-            if let Err(e) = forwarded_handler(stream, shared).await {
-                tracing::error!("Forwarded handler failure {e}");
-            }
-        }
-    }))
-}
diff --git a/xcp-metrics/src/forwarded/request.rs b/xcp-metrics/src/forwarded/request.rs
deleted file mode 100644
index 74152f7..0000000
--- a/xcp-metrics/src/forwarded/request.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-//! [ForwardedRequest] implementation.
-use std::{collections::HashMap, str::FromStr};
-
-use hyper::{
-    header::{ACCEPT, CONTENT_LENGTH, CONTENT_TYPE, HOST, TRANSFER_ENCODING, USER_AGENT},
-    http::uri::PathAndQuery,
-    Request, Version,
-};
-use serde::Deserialize;
-
-/// xapi-project/xen-api/blob/master/ocaml/libs/http-lib/http.ml for reference
-#[derive(Clone, Debug, Deserialize)]
-pub struct ForwardedRequest {
-    pub m: Box<str>,
-    pub uri: Box<str>,
-    pub query: HashMap<Box<str>, Box<str>>,
-    pub version: Box<str>,
-    pub frame: bool,
-    pub transfer_encoding: Option<Box<str>>,
-    pub accept: Option<Box<str>>,
-    pub content_length: Option<usize>,
-    pub auth: Option<Box<[Box<str>]>>,
-    pub cookie: HashMap<Box<str>, Box<str>>,
-    pub task: Option<Box<str>>,
-    pub subtask_of: Option<Box<str>>,
-    pub content_type: Option<Box<str>>,
-    pub host: Option<Box<str>>,
-    pub user_agent: Option<Box<str>>,
-    pub close: bool,
-    pub additional_headers: HashMap<Box<str>, Box<str>>,
-    pub body: Option<Box<str>>,
-    pub traceparent: Option<Box<str>>,
-}
-
-impl TryFrom<ForwardedRequest> for Request<String> {
-    type Error = anyhow::Error;
-
-    fn try_from(request: ForwardedRequest) -> Result<Self, Self::Error> {
-        let mut builder = Request::builder();
-
-        if let Some(version) = match request.version.as_ref() {
-            "HTTP/0.9" => Some(Version::HTTP_09),
-            "HTTP/1.0" => Some(Version::HTTP_10),
-            "HTTP/1.1" => Some(Version::HTTP_11),
-            "HTTP/2.0" => Some(Version::HTTP_2),
-            "HTTP/3.0" => Some(Version::HTTP_3),
-            _ => None,
-        } {
-            builder = builder.version(version);
-        }
-
-        builder = builder.method(request.m.as_ref());
-
-        builder = builder.uri(PathAndQuery::from_str(&request.uri)?);
-
-        if let Some(value) = request.content_length {
-            builder = builder.header(CONTENT_LENGTH, value);
-        }
-
-        if let Some(transfer_encoding) = request.transfer_encoding {
-            builder = builder.header(TRANSFER_ENCODING, transfer_encoding.as_ref());
-        }
-
-        if let Some(accept) = request.accept {
-            builder = builder.header(ACCEPT, accept.as_ref());
-        }
-
-        if let Some(content_type) = request.content_type {
-            builder = builder.header(CONTENT_TYPE, content_type.as_ref());
-        }
-
-        if let Some(host) = request.host {
-            builder = builder.header(HOST, host.as_ref());
-        }
-
-        if let Some(user_agent) = request.user_agent {
-            builder = builder.header(USER_AGENT, user_agent.as_ref());
-        }
-
-        for (name, value) in request.additional_headers.iter() {
-            builder = builder.header(name.as_ref(), value.as_ref());
-        }
-
-        Ok(builder.body(match request.body {
-            Some(content) => content.into_string(),
-            None => String::new(),
-        })?)
-    }
-}
diff --git a/xcp-metrics/src/forwarded/response.rs b/xcp-metrics/src/forwarded/response.rs
deleted file mode 100644
index 7e88b4b..0000000
--- a/xcp-metrics/src/forwarded/response.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//! [write_response] implementation
-use std::{fmt::Debug, io::Write};
-
-use http_body_util::{BodyExt, Full};
-use hyper::{body::Bytes, http::Response};
-
-/// Write the HTTP response into some writer.
-pub async fn write_response<W>(
-    writer: &mut W,
-    response: Response<Full<Bytes>>,
-) -> Result<(), anyhow::Error>
-where
-    W: Write + Debug,
-{
-    tracing::trace!("Sending HTTP response {response:?} to {writer:?}");
-
-    write!(
-        writer,
-        "HTTP/1.1 {} {}\r\n",
-        response.status().as_u16(),
-        response.status().canonical_reason().unwrap_or_default()
-    )?;
-
-    let (mut parts, body) = response.into_parts();
-    let body = body.collect().await?.to_bytes();
-
-    // Add content-length if not defined
-    if !parts.headers.contains_key("content-length") {
-        let body_length = body.len();
-        parts.headers.insert("content-length", body_length.into());
-    }
-
-    for (name, value) in parts.headers {
-        if let Some(name) = name {
-            write!(
-                writer,
-                "{}: {}\r\n",
-                name.as_str(),
-                String::from_utf8_lossy(value.as_bytes())
-            )?;
-        }
-    }
-
-    write!(writer, "\r\n")?;
-    writer.write_all(&body)?;
-
-    Ok(())
-}
diff --git a/xcp-metrics/src/forwarded/routes.rs b/xcp-metrics/src/forwarded/routes.rs
deleted file mode 100644
index 2435b6f..0000000
--- a/xcp-metrics/src/forwarded/routes.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! Forwarded routes
-use std::{
-    sync::Arc,
-    time::{Duration, SystemTime},
-};
-
-use http_body_util::Full;
-use tokio::sync::mpsc;
-
-use hyper::{body::Bytes, Response};
-
-use crate::{
-    publishers::rrdd::{server::RrddServerMessage, RrdXportFilter, RrdXportParameters},
-    rpc, XcpMetricsShared,
-};
-
-use super::request::ForwardedRequest;
-
-pub(super) async fn route_forwarded(
-    shared: Arc<XcpMetricsShared>,
-    request: ForwardedRequest,
-) -> anyhow::Result<Response<Full<Bytes>>> {
-    match request.uri.as_ref() {
-        "/rrd_updates" => rrd_update_handler(shared, request).await,
-        "/" => Ok(rpc::entrypoint(shared, request.try_into()?).await.unwrap()),
-        _ => Response::builder()
-            .status(404)
-            .body("Invalid request".into())
-            .map_err(|err| anyhow::anyhow!(err)),
-    }
-}
-
-async fn rrd_update_handler(
-    shared: Arc<XcpMetricsShared>,
-    request: ForwardedRequest,
-) -> anyhow::Result<Response<Full<Bytes>>> {
-    let (tx, mut rx) = mpsc::channel(1);
-
-    let with_host = request
-        .query
-        .get("host")
-        .map(|v| v.as_ref() == "true")
-        .unwrap_or(false);
-
-    let use_json = request
-        .query
-        .get("json")
-        .map(|v| v.as_ref() == "true")
-        .unwrap_or(false);
-
-    let filter = if with_host {
-        RrdXportFilter::All
-    } else {
-        RrdXportFilter::AllNoHost
-    };
-
-    let start = if let Some(value) = request.query.get("start") {
-        let since_epoch = value.parse()?;
-
-        SystemTime::UNIX_EPOCH + Duration::from_secs(since_epoch)
-    } else {
-        SystemTime::now()
-    };
-
-    let interval = if let Some(value) = request.query.get("interval") {
-        value.parse()?
-    } else {
-        1
-    };
-
-    shared
-        .rrdd_channel
-        .send(RrddServerMessage::RequestRrdUpdates(
-            RrdXportParameters {
-                start,
-                interval,
-                filter,
-            },
-            tx,
-        ))?;
-
-    let response = rx
-        .recv()
-        .await
-        .ok_or(anyhow::anyhow!("No value received from channel"))??;
-
-    let body = if use_json {
-        response.to_json5()?
-    } else {
-        response.to_json()?
-    };
-
-    Response::builder()
-        .status(200)
-        .body(body.into())
-        .map_err(|err| anyhow::anyhow!(err))
-}
diff --git a/xcp-metrics/src/hub.rs b/xcp-metrics/src/hub.rs
index a47f171..f79917a 100644
--- a/xcp-metrics/src/hub.rs
+++ b/xcp-metrics/src/hub.rs
@@ -2,63 +2,37 @@
 # Metrics Hub
 
 This is the part that centralize the metrics from the main daemon.
-It communicates metrics with [crate::publishers] (pull) and [crate::providers] (push) using a [`mpsc::UnboundedSender<HubPullResponse>`].
+It communicates metrics with [crate::publishers] (pull) and [crate::providers] (push) using
+a [`oneshot::Sender<HubPullResponse>`].
 
-All metrics are uniquely identified using a [uuid::Uuid] to ease updating, this identifier must be generated by the provider (using [uuid::Uuid::new_v4]).
-
-## TODO
-
-Metrics families should be able to be merged if needed.
+All metrics are uniquely identified using a [uuid::Uuid] to ease updating, this identifier
+must be generated by the provider (using [uuid::Uuid::new_v4]).
 */
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 
 use tokio::{
-    sync::mpsc,
+    sync::{mpsc, oneshot},
     task::{self, JoinHandle},
 };
-use xcp_metrics_common::metrics::{Metric, MetricFamily, MetricPoint, MetricSet, MetricType};
-
-/// Register a new metric family to the hub.
-#[derive(Debug, Clone)]
-pub struct CreateFamily {
-    pub name: Box<str>,
-    pub metric_type: MetricType,
-    pub unit: Box<str>,
-    pub help: Box<str>,
-}
-
-/// Register a new metric to the hub.
-#[derive(Debug, Clone)]
-pub struct RegisterMetrics {
-    pub family: Box<str>,
-    pub metrics: Metric,
-    pub uuid: uuid::Uuid,
-}
-
-/// Remove a metric from the hub.
-#[derive(Debug, Clone)]
-pub struct UnregisterMetrics {
-    pub uuid: uuid::Uuid,
-}
+use xcp_metrics_common::{
+    metrics::{MetricFamily, MetricSet},
+    protocol::{CreateFamily, RemoveFamily, RemoveMetric, UpdateMetric},
+};
 
-/// Replace the values of a metric.
-#[derive(Debug, Clone)]
-pub struct UpdateMetrics {
-    pub uuid: uuid::Uuid,
-    pub new_values: Box<[MetricPoint]>,
-}
-
-/// Fetch metrics, receiving them in a provided [`mpsc::UnboundedSender<HubPullResponse>`].
-#[derive(Debug, Clone)]
-pub struct PullMetrics(pub mpsc::UnboundedSender<HubPullResponse>);
+/// Fetch metrics, receiving them in a provided [`oneshot::Sender<HubPullResponse>`].
+#[derive(Debug)]
+pub struct PullMetrics(pub oneshot::Sender<HubPullResponse>);
 
 /// A message that can be sent to the hub.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum HubPushMessage {
+    // xcp-metrics protocol messages
     CreateFamily(CreateFamily),
-    RegisterMetrics(RegisterMetrics),
-    UnregisterMetrics(UnregisterMetrics),
-    UpdateMetrics(UpdateMetrics),
+    RemoveFamily(RemoveFamily),
+    UpdateMetric(UpdateMetric),
+    RemoveMetric(RemoveMetric),
+
+    // Hub-specific messages
     PullMetrics(PullMetrics),
 }
 
@@ -75,14 +49,15 @@ pub struct MetricsHub {
 }
 
 impl MetricsHub {
-    /// Starts the Metrics Hub in a new [tokio::task], giving the associated [JoinHandle] and hub channel ([`mpsc::UnboundedSender<HubPushMessage>`]).
+    /// Starts the Metrics Hub in a new [tokio::task], giving the associated [JoinHandle]
+    /// and hub channel ([`mpsc::UnboundedSender<HubPushMessage>`]).
     pub async fn start(self) -> (JoinHandle<()>, mpsc::UnboundedSender<HubPushMessage>) {
         let (sender, receiver) = mpsc::unbounded_channel();
-        let mut rendez_vous = mpsc::channel(1);
+        let rendez_vous = oneshot::channel();
 
         let handle = task::spawn(async move { self.run(receiver, rendez_vous.0).await });
 
-        rendez_vous.1.recv().await;
+        rendez_vous.1.await.unwrap();
 
         tracing::info!("Hub ready");
 
@@ -92,16 +67,16 @@ impl MetricsHub {
     async fn run(
         mut self,
         mut receiver: mpsc::UnboundedReceiver<HubPushMessage>,
-        rendez_vous: mpsc::Sender<()>,
+        rendez_vous: oneshot::Sender<()>,
     ) {
-        rendez_vous.send(()).await.unwrap();
+        rendez_vous.send(()).ok();
 
         while let Some(msg) = receiver.recv().await {
             match msg {
                 HubPushMessage::CreateFamily(message) => self.create_family(message).await,
-                HubPushMessage::RegisterMetrics(message) => self.register(message).await,
-                HubPushMessage::UnregisterMetrics(message) => self.unregister(message).await,
-                HubPushMessage::UpdateMetrics(message) => self.update(message).await,
+                HubPushMessage::RemoveFamily(message) => self.remove_family(message).await,
+                HubPushMessage::UpdateMetric(message) => self.update_metric(message).await,
+                HubPushMessage::RemoveMetric(message) => self.remove_metric(message).await,
                 HubPushMessage::PullMetrics(message) => self.pull_metrics(message).await,
             }
         }
@@ -119,83 +94,78 @@ impl MetricsHub {
     ) {
         let metrics = Arc::make_mut(&mut self.metrics);
 
-        if let Some(old_family) = metrics.families.insert(
-            name,
-            MetricFamily {
-                metric_type,
-                unit,
-                help,
-                metrics: Default::default(),
-            },
-        ) {
-            tracing::warn!("Overriden previous family: {old_family:?}");
-        }
+        if let Some(previous_family) = metrics.families.get_mut(&name) {
+            // Check for conflicts
+            if previous_family.metric_type != metric_type
+                || previous_family.unit != unit
+                || previous_family.help != help
+            {
+                tracing::warn!("Incompatible families {previous_family:?} != (type={metric_type}, unit={unit}, help={help})");
+            }
 
-        tracing::debug!("Inserted family");
+            previous_family.reference_count += 1;
+        } else {
+            // No existing family.
+            metrics.families.insert(
+                name,
+                MetricFamily {
+                    reference_count: 1,
+                    metric_type,
+                    unit: unit.clone(),
+                    help: help.clone(),
+                    metrics: HashMap::default(),
+                },
+            );
+        }
     }
 
     #[tracing::instrument(skip(self))]
-    async fn register(&mut self, message: RegisterMetrics) {
+    async fn remove_family(&mut self, RemoveFamily { name }: RemoveFamily) {
         let metrics = Arc::make_mut(&mut self.metrics);
 
-        let family = match metrics.families.get_mut(&message.family) {
-            Some(f) => f,
-            None => {
-                tracing::warn!("Missing family, creating default one");
-
-                metrics
-                    .families
-                    .insert(message.family.clone(), Default::default());
-                metrics.families.get_mut(&message.family).unwrap()
-            }
+        let Some(family) = metrics.families.get_mut(&name) else {
+            tracing::warn!("Tried to remove missing family {name}");
+            return;
         };
 
-        if let Some(old) = family.metrics.insert(message.uuid, message.metrics) {
-            tracing::warn!("Overriden {old:?}");
+        family.reference_count -= 1;
+
+        if family.reference_count == 0 {
+            metrics.families.remove(&name);
         }
     }
 
     #[tracing::instrument(skip(self))]
-    async fn unregister(&mut self, message: UnregisterMetrics) {
+    async fn remove_metric(&mut self, RemoveMetric { family_name, uuid }: RemoveMetric) {
         let metrics = Arc::make_mut(&mut self.metrics);
-        let mut deprecated_family = None;
-
-        for (family_name, family) in metrics.families.iter_mut() {
-            if family.metrics.remove(&message.uuid).is_some() {
-                tracing::info!("Unregistered {}", message.uuid);
 
-                // Remove metric family if now empty.
-                if family.metrics.is_empty() {
-                    deprecated_family.replace(family_name.clone());
-                }
-
-                break;
-            }
-        }
+        let Some(family) = metrics.families.get_mut(&family_name) else {
+            tracing::warn!("Missing family '{family_name}'");
+            return;
+        };
 
-        if let Some(name) = &deprecated_family {
-            tracing::info!("Unregistered empty metric family {name}");
-            metrics.families.remove(name);
+        if family.metrics.remove(&uuid).is_none() {
+            tracing::warn!("Tried to remove missing metric '{family_name}:{uuid}'");
         }
     }
 
     #[tracing::instrument(skip(self))]
-    async fn update(&mut self, mut message: UpdateMetrics) {
+    async fn update_metric(
+        &mut self,
+        UpdateMetric {
+            family_name,
+            metric,
+            uuid,
+        }: UpdateMetric,
+    ) {
         let metrics = Arc::make_mut(&mut self.metrics);
 
-        // TODO: Do some checks.
-
-        for (_, family) in metrics.families.iter_mut() {
-            if let Some(metrics) = family.metrics.get_mut(&message.uuid) {
-                tracing::debug!("Metric {} properly updated", message.uuid);
-
-                /* Rust wizardry */
-                std::mem::swap(&mut metrics.metrics_point, &mut message.new_values);
-                return;
-            }
-        }
+        let Some(family) = metrics.families.get_mut(&family_name) else {
+            tracing::warn!("Missing family '{family_name}'");
+            return;
+        };
 
-        tracing::error!("Metric not found");
+        family.metrics.insert(uuid, metric);
     }
 
     #[tracing::instrument(skip(self))]
@@ -204,7 +174,7 @@ impl MetricsHub {
         tracing::debug!("Pulling metrics");
 
         if let Err(e) = sender.send(HubPullResponse::Metrics(Arc::clone(&self.metrics))) {
-            tracing::error!("Error occured while sending metrics {e}");
+            tracing::error!("Error occured while sending metrics {e:?}");
         }
     }
 }
diff --git a/xcp-metrics/src/main.rs b/xcp-metrics/src/main.rs
index 9a714a3..4634d18 100644
--- a/xcp-metrics/src/main.rs
+++ b/xcp-metrics/src/main.rs
@@ -1,37 +1,15 @@
-pub mod forwarded;
 pub mod hub;
-mod mappings;
-pub mod providers;
-pub mod publishers;
 pub mod rpc;
 
 use std::{
-    collections::HashMap,
     fs,
     path::{Path, PathBuf},
-    sync::Arc,
 };
 
 use clap::{command, Parser};
-use dashmap::DashMap;
-use tokio::{net::UnixStream, select, sync::mpsc, task::JoinHandle};
+use tokio::{net::UnixStream, select};
 
-use publishers::rrdd::server::{RrddServer, RrddServerMessage};
-
-use xcp_metrics_common::utils::mapping::CustomMapping;
-
-/// Shared xcp-metrics structure.
-#[derive(Debug)]
-pub struct XcpMetricsShared {
-    /// Handles of the tasks associated to each [providers]
-    pub plugins: DashMap<Box<str>, JoinHandle<()>>,
-
-    /// Channel to communicate with hub.
-    pub hub_channel: mpsc::UnboundedSender<hub::HubPushMessage>,
-
-    /// Channel to communicate with the rrdd compatibility server.
-    pub rrdd_channel: mpsc::UnboundedSender<RrddServerMessage>,
-}
+use xcp_metrics_common::protocol;
 
 /// xcp-metrics main daemon
 #[derive(Parser, Debug)]
@@ -44,13 +22,9 @@ struct Args {
     /// xcp-metrics socket path
     #[arg(long)]
     daemon_path: Option<PathBuf>,
-
-    /// Custom RrddServer v3-to-v2 mapping file.
-    #[arg(short, long)]
-    mapping_file: Option<PathBuf>,
 }
 
-/// Check if the XAPI socket is active and unlink it if it isn't.
+/// Check if the Unix socket is active and unlink it if it isn't.
 ///
 /// Returns true if the socket is active.
 async fn check_unix_socket(socket_path: &Path) -> anyhow::Result<bool> {
@@ -66,14 +40,14 @@ async fn check_unix_socket(socket_path: &Path) -> anyhow::Result<bool> {
                 // Unlink socket
                 tracing::warn!(
                     socket = socket_path.to_str(),
-                    "Unlinking inactive XAPI socket"
+                    "Unlinking inactive xcp-metrics socket"
                 );
                 fs::remove_file(socket_path)?;
                 Ok(false)
             } else {
                 tracing::error!(
                     socket = socket_path.to_str(),
-                    "Unable to check XAPI socket status: {e}"
+                    "Unable to check xcp-metrics socket status: {e}"
                 );
                 Err(e.into())
             }
@@ -81,17 +55,6 @@ async fn check_unix_socket(socket_path: &Path) -> anyhow::Result<bool> {
     }
 }
 
-/// Load the mappings from file or use default ones (for now).
-async fn get_mappings(
-    mapping_path: Option<&Path>,
-) -> anyhow::Result<HashMap<Box<str>, CustomMapping>> {
-    if let Some(path) = mapping_path {
-        Ok(serde_json::from_str(&fs::read_to_string(path)?)?)
-    } else {
-        Ok(mappings::default_mappings())
-    }
-}
-
 #[tokio::main]
 async fn main() {
     let args = Args::parse();
@@ -104,66 +67,21 @@ async fn main() {
 
     tracing::subscriber::set_global_default(text_subscriber).unwrap();
 
-    // Use xcp-rrdd socket path if arg0 is xcp-rrdd and not specified in Args.
-    let socket_path = args.daemon_path.unwrap_or_else(|| {
-        let Some(arg0) = std::env::args().next() else {
-            return xapi::unix::get_module_path("xcp-metrics");
-        };
-
-        let arg0_pathname = Path::new(&arg0)
-            .file_name()
-            .unwrap_or_default()
-            .to_string_lossy();
-
-        if arg0_pathname == "xcp-rrdd" {
-            tracing::info!("Program name is xcp-rrdd, use xcp-rrdd socket path by default");
-            return xapi::unix::get_module_path("xcp-rrdd");
-        }
-
-        xapi::unix::get_module_path("xcp-metrics")
-    });
-
-    let forwarded_path = format!("{}.forwarded", socket_path.to_string_lossy());
+    let socket_path = args
+        .daemon_path
+        .unwrap_or_else(|| protocol::METRICS_SOCKET_PATH.into());
 
     if check_unix_socket(Path::new(&socket_path)).await.unwrap() {
         tracing::error!("Unable to start: xcp-metrics socket is active");
         panic!("Unable to start: is xcp-metrics already running ?");
     }
 
-    if check_unix_socket(Path::new(&forwarded_path)).await.unwrap() {
-        tracing::error!("Unable to start: xcp-metrics.forwarded socket is active");
-        panic!("Unable to start: is xcp-metrics already running ?");
-    }
-
     let (hub, hub_channel) = hub::MetricsHub::default().start().await;
-    let (rrdd_server, rrdd_channel) = RrddServer::new(
-        get_mappings(args.mapping_file.as_deref())
-            .await
-            .expect("Unable to load mappings"),
-    );
-
-    let shared = Arc::new(XcpMetricsShared {
-        hub_channel,
-        plugins: Default::default(),
-        rrdd_channel,
-    });
-
-    let socket = rpc::start_daemon(&socket_path, shared.clone())
-        .await
-        .expect(&format!("Unable to start RPC daemon ({socket_path:?})"));
-
-    let socket_forwarded =
-        forwarded::start_forwarded_socket(Path::new(&forwarded_path), shared.clone())
-            .await
-            .expect("Unable to start RPC Forwarded Socket");
-
-    let rrdd = rrdd_server.start(shared.hub_channel.clone());
+    let rpc_task = rpc::run(&socket_path, hub_channel);
 
     select! {
         res = hub => tracing::warn!("Hub returned: {res:?}"),
-        res = socket => tracing::warn!("RPC Socket returned: {res:?}"),
-        res = socket_forwarded => tracing::warn!("RPC Forwarded Socket returned {res:?}"),
-        res = rrdd => tracing::warn!("RRDD server returned {res:?}")
+        res = rpc_task => tracing::warn!("RPC Socket returned: {res:?}"),
     };
 
     tracing::info!("Stopping");
diff --git a/xcp-metrics/src/mappings.rs b/xcp-metrics/src/mappings.rs
deleted file mode 100644
index 70c9c50..0000000
--- a/xcp-metrics/src/mappings.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! Protocol v2 to protocol v3 predefined [CustomMapping]s.
-use std::collections::HashMap;
-
-use maplit::hashmap;
-use xcp_metrics_common::utils::mapping::CustomMapping;
-
-pub fn default_mappings() -> HashMap<Box<str>, CustomMapping> {
-    hashmap! {
-        "cpu-cstate".into() => CustomMapping {
-            pattern: "cpu{id}-C{state}".into(),
-            min: 0.0,
-            max: f32::INFINITY,
-            default: true,
-        },
-        "cpu-pstate".into() => CustomMapping {
-            pattern: "cpu{id}-P{state}".into(),
-            min: 0.0,
-            max: f32::INFINITY,
-            default: true,
-        },
-        "cpu".into() => CustomMapping {
-            pattern: "cpu{id}".into(),
-            min: 0.0,
-            max: 1.0,
-            default: true,
-        },
-        "cpu-freq".into() => CustomMapping {
-            pattern: "CPU{id}-avg-freq".into(),
-            min: 0.0,
-            max: f32::INFINITY,
-            default: true
-        },
-    }
-}
diff --git a/xcp-metrics/src/providers/mod.rs b/xcp-metrics/src/providers/mod.rs
deleted file mode 100644
index e932c6d..0000000
--- a/xcp-metrics/src/providers/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Metrics providers.
-use tokio::{sync::mpsc, task::JoinHandle};
-
-use crate::hub::HubPushMessage;
-
-pub mod protocol_v2;
-pub mod protocol_v3;
-
-pub trait Provider {
-    fn start_provider(self, hub_channel: mpsc::UnboundedSender<HubPushMessage>) -> JoinHandle<()>;
-}
diff --git a/xcp-metrics/src/providers/protocol_v2.rs b/xcp-metrics/src/providers/protocol_v2.rs
deleted file mode 100644
index 0fa84de..0000000
--- a/xcp-metrics/src/providers/protocol_v2.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-//! Protocol v2 plugin metrics provider
-use std::{
-    collections::HashMap,
-    path::{Path, PathBuf},
-    time::{Duration, SystemTime},
-};
-
-use tokio::{
-    fs::File,
-    io::AsyncReadExt,
-    sync::mpsc,
-    task::{self, JoinHandle},
-    time,
-};
-use xcp_metrics_common::{
-    metrics::{Metric, MetricPoint},
-    rrdd::{
-        protocol_common::DataSourceValue,
-        protocol_v2::{RrddMessageHeader, RrddMetadata, RrddMetadataRaw},
-    },
-};
-
-use super::Provider;
-use crate::hub::{CreateFamily, HubPushMessage, RegisterMetrics, UnregisterMetrics, UpdateMetrics};
-
-const METRICS_SHM_PATH: &str = "/dev/shm/metrics/";
-
-#[derive(Debug, Clone)]
-struct PluginData {
-    metadata: RrddMetadata,
-    values: Box<[DataSourceValue]>,
-    metadata_checksum: u32,
-    timestamp: SystemTime,
-}
-
-#[derive(Debug, Clone)]
-pub struct ProtocolV2Provider {
-    name: Box<str>,
-    path: PathBuf,
-    state: Option<PluginData>,
-    registered_metrics: HashMap<Box<str>, uuid::Uuid>,
-    hub_channel: Option<mpsc::UnboundedSender<HubPushMessage>>,
-    last_reset: SystemTime,
-}
-
-impl ProtocolV2Provider {
-    pub fn new(plugin_name: &str) -> Self {
-        Self {
-            name: plugin_name.into(),
-            path: Path::new(METRICS_SHM_PATH).join(plugin_name),
-            state: None,
-            registered_metrics: HashMap::new(),
-            hub_channel: None,
-            last_reset: SystemTime::now(),
-        }
-    }
-
-    async fn collect_plugin_metrics(&mut self) -> anyhow::Result<bool> {
-        let mut file = File::open(&self.path).await?;
-        let header = RrddMessageHeader::parse_async(&mut file).await;
-        let mut updated_metadata = false;
-
-        tracing::debug!("Readed {header:?}");
-
-        if let Ok(header) = header {
-            // Get the most up to date PluginData.
-            let mut data = match self.state.as_ref() {
-                /* matching checksums, no need to update metadata */
-                Some(
-                    data @ &PluginData {
-                        metadata_checksum, ..
-                    },
-                ) if metadata_checksum == header.metadata_checksum => (*data).clone(),
-
-                /* Regenerate data */
-                _ => {
-                    updated_metadata = true;
-                    self.last_reset = SystemTime::now();
-
-                    // Read metadata
-                    let mut metadata_string = vec![0u8; header.metadata_length as usize];
-                    file.read_exact(&mut metadata_string).await?;
-                    let metadata: RrddMetadata =
-                        serde_json::from_slice::<RrddMetadataRaw>(&metadata_string)?.try_into()?;
-
-                    PluginData {
-                        values: vec![DataSourceValue::Undefined; metadata.datasources.len()]
-                            .into_boxed_slice(),
-                        metadata,
-                        metadata_checksum: header.metadata_checksum,
-                        timestamp: header.timestamp,
-                    }
-                }
-            };
-
-            // Update data value slice using raw values in header along with metadata.
-            data.values
-                .iter_mut()
-                .zip(data.metadata.datasources.values())
-                .zip(header.values.iter())
-                .for_each(|((dest, meta), &raw)| {
-                    *dest = match meta.value {
-                        DataSourceValue::Int64(_) => {
-                            DataSourceValue::Int64(i64::from_be_bytes(raw))
-                        }
-                        DataSourceValue::Float(_) => {
-                            DataSourceValue::Float(f64::from_be_bytes(raw))
-                        }
-                        DataSourceValue::Undefined => DataSourceValue::Undefined,
-                    }
-                });
-
-            data.timestamp = header.timestamp;
-
-            self.state.replace(data);
-        }
-
-        Ok(updated_metadata)
-    }
-
-    /// Send metrics to hub, registering them if they are not.
-    async fn send_values(&mut self, hub_channel: &mpsc::UnboundedSender<HubPushMessage>) {
-        let Some(state) = self.state.as_ref() else {
-            return;
-        };
-
-        std::iter::zip(state.metadata.datasources.iter(), state.values.iter()).for_each(
-            |((name, metadata), &value)| {
-                // Wrap value into its appropriate MetricPoint.
-                let metric_point = MetricPoint::from_protocol_v2(
-                    metadata,
-                    value,
-                    state.timestamp,
-                    Some(self.last_reset),
-                );
-
-                match self.registered_metrics.get(name) {
-                    Some(&uuid) => {
-                        // Update metrics values
-                        let new_values = vec![metric_point].into_boxed_slice();
-
-                        hub_channel
-                            .send(HubPushMessage::UpdateMetrics(UpdateMetrics {
-                                new_values,
-                                uuid,
-                            }))
-                            .unwrap();
-                    }
-                    None => {
-                        // Not yet registered, register it.
-                        let metric_uuid = uuid::Uuid::new_v4();
-
-                        // Register family
-                        hub_channel
-                            .send(HubPushMessage::CreateFamily(CreateFamily {
-                                name: name.clone(),
-                                metric_type: metric_point.value.get_type(),
-                                unit: metadata.units.clone(),
-                                help: metadata.description.clone(),
-                            }))
-                            .unwrap();
-
-                        // Register metric
-                        hub_channel
-                            .send(HubPushMessage::RegisterMetrics(RegisterMetrics {
-                                family: name.clone(),
-                                uuid: metric_uuid,
-                                metrics: Metric::from_protocol_v2(
-                                    metadata,
-                                    value,
-                                    state.timestamp,
-                                    Some(self.last_reset),
-                                ),
-                            }))
-                            .unwrap();
-
-                        self.registered_metrics.insert(name.clone(), metric_uuid);
-                    }
-                };
-            },
-        );
-    }
-
-    fn check_metrics(&mut self, hub_channel: &mpsc::UnboundedSender<HubPushMessage>) {
-        let Some(state) = &self.state else { return };
-
-        self.registered_metrics.retain(|key, &mut uuid| {
-            // Check if the key exists in the new metadata.
-            if !state.metadata.datasources.contains_key(key) {
-                // missing: unregister
-                hub_channel
-                    .send(HubPushMessage::UnregisterMetrics(UnregisterMetrics {
-                        uuid,
-                    }))
-                    .ok();
-
-                false
-            } else {
-                true
-            }
-        })
-    }
-}
-
-impl Provider for ProtocolV2Provider {
-    fn start_provider(
-        mut self,
-        hub_channel: mpsc::UnboundedSender<HubPushMessage>,
-    ) -> JoinHandle<()> {
-        self.hub_channel.replace(hub_channel.clone());
-
-        task::spawn(async move {
-            tracing::trace_span!("plugin (v2) {}", self.name);
-
-            loop {
-                let updated_metadata = self.collect_plugin_metrics().await;
-
-                if let Ok(true) = updated_metadata {
-                    tracing::info!("Updated metadata");
-                }
-
-                tracing::debug!("New state: {:?}", self.state);
-
-                match updated_metadata {
-                    // Check for removed metrics
-                    Ok(true) => self.check_metrics(&hub_channel),
-                    Ok(false) => (),
-                    Err(e) => tracing::error!("{e}"),
-                }
-
-                self.send_values(&hub_channel).await;
-
-                time::sleep(Duration::from_secs(5)).await
-            }
-        })
-    }
-}
-
-impl Drop for ProtocolV2Provider {
-    fn drop(&mut self) {
-        // Unregister plugins
-        if let Some(hub_channel) = &self.hub_channel {
-            self.registered_metrics.iter().for_each(|(name, &uuid)| {
-                tracing::info!("Unregistering {name}");
-
-                hub_channel
-                    .send(HubPushMessage::UnregisterMetrics(UnregisterMetrics {
-                        uuid,
-                    }))
-                    .ok(); // ignore failure (destroyed hub ?)
-            });
-        }
-    }
-}
diff --git a/xcp-metrics/src/providers/protocol_v3.rs b/xcp-metrics/src/providers/protocol_v3.rs
deleted file mode 100644
index 0bf2592..0000000
--- a/xcp-metrics/src/providers/protocol_v3.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-//! Protocol v3 plugin metrics provider
-
-use std::{
-    path::{Path, PathBuf},
-    time::{Duration, SystemTime},
-};
-
-use tokio::{fs::File, sync::mpsc, task::JoinHandle, time};
-use xcp_metrics_common::{metrics::MetricSet, protocol_v3, utils::delta::MetricSetModel};
-
-use crate::hub::{CreateFamily, HubPushMessage, RegisterMetrics, UnregisterMetrics, UpdateMetrics};
-
-use super::Provider;
-
-const METRICS_SHM_PATH: &str = "/dev/shm/metrics/";
-
-#[derive(Debug, Clone)]
-pub struct ProtocolV3Provider {
-    name: Box<str>,
-    path: PathBuf,
-    last_timestamp: SystemTime,
-
-    model: MetricSetModel,
-}
-
-impl ProtocolV3Provider {
-    pub fn new(plugin_name: &str) -> Self {
-        Self {
-            name: plugin_name.into(),
-            path: Path::new(METRICS_SHM_PATH).join(plugin_name),
-            last_timestamp: SystemTime::now(),
-            model: MetricSetModel::default(),
-        }
-    }
-
-    async fn fetch_protocol_v3(&self) -> anyhow::Result<Option<MetricSet>> {
-        let mut file = File::open(&self.path).await?;
-
-        // Read metrics
-        let (header, metrics) = protocol_v3::parse_v3_async(&mut file).await?;
-
-        if header.timestamp == self.last_timestamp {
-            tracing::debug!("Metrics have not been updated");
-            return Ok(None);
-        }
-
-        Ok(Some(metrics))
-    }
-}
-
-impl Provider for ProtocolV3Provider {
-    fn start_provider(
-        mut self,
-        hub_channel: mpsc::UnboundedSender<HubPushMessage>,
-    ) -> JoinHandle<()> {
-        tokio::task::spawn(async move {
-            tracing::debug_span!("Plugin {}", self.name);
-
-            loop {
-                match self.fetch_protocol_v3().await {
-                    Ok(Some(new_metrics)) => {
-                        let delta = self.model.compute_delta(&new_metrics);
-
-                        // Update model
-                        self.model.apply_delta(&delta);
-
-                        // Remove metrics
-                        delta.removed_metrics.into_iter().for_each(|uuid| {
-                            if let Err(e) = hub_channel.send(HubPushMessage::UnregisterMetrics(
-                                UnregisterMetrics { uuid },
-                            )) {
-                                tracing::error!("Unregister error {e}");
-                            }
-                        });
-
-                        // Add new families
-                        delta.added_families.into_iter().for_each(|(name, family)| {
-                            if let Err(e) =
-                                hub_channel.send(HubPushMessage::CreateFamily(CreateFamily {
-                                    name: name.into(),
-                                    metric_type: family.metric_type,
-                                    unit: family.unit.clone(),
-                                    help: family.help.clone(),
-                                }))
-                            {
-                                tracing::error!("Register error {e}");
-                            }
-                        });
-
-                        // Add new metrics
-                        delta
-                            .added_metrics
-                            .into_iter()
-                            .for_each(|(family, metrics, uuid)| {
-                                if let Err(e) = hub_channel.send(HubPushMessage::RegisterMetrics(
-                                    RegisterMetrics {
-                                        family: family.into(),
-                                        metrics: (*metrics).clone(),
-                                        uuid,
-                                    },
-                                )) {
-                                    tracing::error!("Unregister error {e}");
-                                }
-                            });
-
-                        // Update all metrics
-                        new_metrics.families.into_iter().for_each(|(name, family)| {
-                            family.metrics.into_iter().for_each(|(_, metric)| {
-                                let uuid = self.model.metrics_map[&(name.clone(), metric.labels)];
-
-                                if let Err(e) =
-                                    hub_channel.send(HubPushMessage::UpdateMetrics(UpdateMetrics {
-                                        uuid,
-                                        new_values: metric.metrics_point.clone(),
-                                    }))
-                                {
-                                    tracing::error!("Update error {e}");
-                                }
-                            });
-                        });
-                    }
-                    Ok(None) => {}
-                    Err(e) => {
-                        tracing::warn!("Unable to fetch metrics: {e}")
-                    }
-                }
-
-                time::sleep(Duration::from_secs(5)).await
-            }
-        })
-    }
-}
diff --git a/xcp-metrics/src/publishers/mod.rs b/xcp-metrics/src/publishers/mod.rs
deleted file mode 100644
index c6c7f9c..0000000
--- a/xcp-metrics/src/publishers/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Metrics publishers
-pub mod openmetrics;
-pub mod rrdd;
diff --git a/xcp-metrics/src/publishers/openmetrics.rs b/xcp-metrics/src/publishers/openmetrics.rs
deleted file mode 100644
index 1017306..0000000
--- a/xcp-metrics/src/publishers/openmetrics.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//! OpenMetrics based metrics publisher
-use std::sync::Arc;
-
-use http::Response;
-use hyper::body::Bytes;
-use tokio::sync::mpsc;
-
-use xapi::rpc::{message::request::RpcRequest, methods::rrdd::OpenMetricsMethod};
-use xcp_metrics_common::{
-    metrics::MetricSet,
-    openmetrics::{self, prost::Message, text},
-};
-
-use crate::{
-    hub::{HubPullResponse, HubPushMessage, PullMetrics},
-    XcpMetricsShared,
-};
-
-fn generate_openmetrics_message(metrics: MetricSet) -> Vec<u8> {
-    openmetrics::MetricSet::from(metrics).encode_to_vec()
-}
-
-fn generate_openmetrics_text_message(metrics: MetricSet) -> Vec<u8> {
-    let mut output = String::new();
-
-    text::write_metrics_set_text(&mut output, &metrics).unwrap();
-
-    output.into_bytes()
-}
-
-const OPENMETRICS_TEXT_CONTENT_TYPE: &str =
-    "application/openmetrics-text; version=1.0.0; charset=utf-8";
-const OPENMETRICS_PROTOBUF_CONTENT_TYPE: &str = "application/openmetrics-protobuf; version=1.0.0";
-
-pub async fn run(
-    shared: Arc<XcpMetricsShared>,
-    request: RpcRequest,
-) -> anyhow::Result<Response<Bytes>> {
-    tracing::info_span!("Open Metrics query");
-    tracing::debug!("Preparing query");
-
-    let use_protobuf = request
-        .try_into_method::<OpenMetricsMethod>()
-        .map_or(false, |method| method.protobuf);
-
-    let (sender, mut receiver) = mpsc::unbounded_channel();
-
-    shared
-        .hub_channel
-        .send(HubPushMessage::PullMetrics(PullMetrics(sender)))?;
-
-    let Some(HubPullResponse::Metrics(metrics)) = receiver.recv().await else {
-        anyhow::bail!("Unable to fetch metrics from hub")
-    };
-
-    if use_protobuf {
-        let message = generate_openmetrics_message((*metrics).clone());
-
-        Ok(Response::builder()
-            .header("content-type", OPENMETRICS_PROTOBUF_CONTENT_TYPE)
-            .body(message.into())?)
-    } else {
-        let message = generate_openmetrics_text_message((*metrics).clone());
-
-        Ok(Response::builder()
-            .header("content-type", OPENMETRICS_TEXT_CONTENT_TYPE)
-            .body(message.into())?)
-    }
-}
diff --git a/xcp-metrics/src/publishers/rrdd/entry.rs b/xcp-metrics/src/publishers/rrdd/entry.rs
deleted file mode 100644
index a0c7a3c..0000000
--- a/xcp-metrics/src/publishers/rrdd/entry.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//! [RrdEntry] definition
-use serde::{Deserialize, Serialize};
-use xcp_metrics_common::rrdd::protocol_common::DataSourceMetadata;
-
-use super::{round_robin::RoundRobinBuffer, Granuality};
-
-/// A xcp-rrdd metric entry.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct RrdEntry {
-    /// Full entry name (KIND:owner:uuid:metric_name)
-    pub name: Box<str>,
-
-    /// Protocol v2 metadata
-    pub metadata: DataSourceMetadata,
-
-    /// Metrics per five seconds (for the past ten minutes)
-    pub five_seconds: RoundRobinBuffer<f64>,
-
-    /// Metrics per minute (for the past two hours)
-    pub minute: RoundRobinBuffer<f64>,
-
-    /// Metrics per hour (for the past week).
-    pub hour: RoundRobinBuffer<f64>,
-
-    /// Metrics per day (for the past year).
-    pub day: RoundRobinBuffer<f64>,
-}
-
-impl RrdEntry {
-    pub fn new(name: Box<str>, metadata: DataSourceMetadata) -> Self {
-        Self {
-            name,
-            metadata,
-
-            // Per five seconds, past ten minutes.
-            five_seconds: RoundRobinBuffer::new(
-                Granuality::FiveSeconds.get_buffer_size(),
-                f64::NAN,
-            ),
-
-            // Per minute, past ten minutes.
-            minute: RoundRobinBuffer::new(Granuality::Minute.get_buffer_size(), f64::NAN),
-
-            // Per hour, past week.
-            hour: RoundRobinBuffer::new(Granuality::Hour.get_buffer_size(), f64::NAN),
-
-            // Per day, past year.
-            day: RoundRobinBuffer::new(Granuality::Day.get_buffer_size(), f64::NAN),
-        }
-    }
-
-    pub(super) fn get_buffer(&self, granuality: Granuality) -> &RoundRobinBuffer<f64> {
-        match granuality {
-            Granuality::FiveSeconds => &self.five_seconds,
-            Granuality::Minute => &self.minute,
-            Granuality::Hour => &self.hour,
-            Granuality::Day => &self.day,
-        }
-    }
-}
diff --git a/xcp-metrics/src/publishers/rrdd/mod.rs b/xcp-metrics/src/publishers/rrdd/mod.rs
deleted file mode 100644
index 6ddb614..0000000
--- a/xcp-metrics/src/publishers/rrdd/mod.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-/*!
-xcp-rrdd compatible publisher
-
-This module is meant to be a compatibility layer on top of [crate::hub::MetricsHub], instead of being a full blown xcp-rrdd server.
-
-It is exposed mostly through [server::RrddServer], which contains a limited implementation of xcp-rrdd that communicates
-periodically with an external [crate::hub::MetricsHub] to fetch latest metrics.
-As xcp-rrdd uses a protocol-v2-alike metrics representation (instead of [xcp_metrics_common::metrics]), all metrics are passed through a
-[xcp_metrics_common::utils::mapping::MetadataMapping] specified on [server::RrddServer] creation.
-
-All requests to this server uses [server::RrddServerMessage] using the channel provided on [server::RrddServer] creation in a pull-fashion.
-Using the [server::RrddServerMessage::RequestRrdUpdates] message, it is possible to get [xcp_metrics_common::rrdd::rrd_updates::RrdXport] exports,
-that can be used to implement `/rrd_updates`.
-*/
-mod entry;
-pub mod round_robin;
-pub mod server;
-
-use std::time::{Duration, SystemTime};
-
-/// Rrdd Xport metrics filter.
-#[derive(Debug, Clone, Copy)]
-pub enum RrdXportFilter {
-    All,
-    AllNoHost,
-    VM(uuid::Uuid),
-    SR(uuid::Uuid),
-}
-
-/// Rrdd Xport parameters.
-#[derive(Debug, Clone)]
-pub struct RrdXportParameters {
-    pub start: SystemTime,
-    pub interval: u32,
-    pub filter: RrdXportFilter,
-}
-
-#[derive(Copy, Clone)]
-enum Granuality {
-    FiveSeconds,
-    Minute,
-    Hour,
-    Day,
-}
-
-impl Granuality {
-    /// Get the duration covered by this level of granuality.
-    pub const fn get_covered_duration(self) -> Duration {
-        match self {
-            // Duration that can cover the five_seconds buffer (10 minutes).
-            Self::FiveSeconds => Duration::from_secs(10 * 60),
-            // Duration that can cover the minute buffer (2 hours).
-            Self::Minute => Duration::from_secs(2 * 3600),
-            // Duration that can cover the hour buffer (1 weeks).
-            Self::Hour => Duration::from_secs(24 * 7 * 3600),
-            // Duration that can cover the day buffer (1 year).
-            Self::Day => Duration::from_secs(24 * 3600 * 365),
-        }
-    }
-
-    pub const fn get_buffer_size(self) -> usize {
-        match self {
-            // Size of the per five seconds samples buffer.
-            Self::FiveSeconds => 10 * 60 / 5,
-            // Size of the per minute samples buffer.
-            Self::Minute => 2 * 60,
-            // Size of the per hour samples buffer.
-            Self::Hour => 7 * 24,
-            // Size of the per day samples buffer.
-            Self::Day => 365,
-        }
-    }
-
-    /// Number of five-seconds updates between metrics.
-    pub const fn get_five_seconds_interval(self) -> u32 {
-        match self {
-            Self::FiveSeconds => 1,
-            Self::Minute => 60 / 5,
-            Self::Hour => 3600 / 5,
-            Self::Day => 3600 * 24 / 5,
-        }
-    }
-
-    /// Interval between metrics updates.
-    pub const fn get_interval(self) -> Duration {
-        Duration::from_secs(5 * self.get_five_seconds_interval() as u64)
-    }
-}
diff --git a/xcp-metrics/src/publishers/rrdd/round_robin.rs b/xcp-metrics/src/publishers/rrdd/round_robin.rs
deleted file mode 100644
index 3268c26..0000000
--- a/xcp-metrics/src/publishers/rrdd/round_robin.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-// TODO: Redesign parts of it with const generic arrays when serde supports it.
-// https://github.com/serde-rs/serde/issues/1937
-
-/**
-Round-robin buffer.
-
-# Note
-
-Overwrite old data after writing `size` items.
-
-# Design
-
-```plain
-------------------> Items order
-
-+-----------------+
-|....P=>..........|
-+-----------------+
-
-P: Round Robin position
-=> : Next position after push()
-```
-
-New items are written at `P` then increment position (or wrap it to 0 if `P >= size`).
-
-*/
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct RoundRobinBuffer<T: Sized> {
-    pos: usize,
-    size: usize,
-    buffer: Box<[T]>,
-}
-
-impl<T> RoundRobinBuffer<T>
-where
-    T: Sized + Default + Copy,
-{
-    pub fn new(size: usize, default: T) -> Self {
-        Self {
-            pos: 0,
-            size,
-            buffer: vec![default; size].into_boxed_slice(),
-        }
-    }
-
-    pub fn push(&mut self, value: T) {
-        self.buffer[self.pos] = value;
-        self.pos = (self.pos + 1) % self.size;
-    }
-
-    pub fn iter(&self) -> RoundRobinIterator<T> {
-        RoundRobinIterator {
-            rrb: self,
-            pos: self.pos,
-            done: false,
-        }
-    }
-}
-
-/**
-Iterator for Round-Robin buffer.
-
-# Design
-
-```plain
-------------------> Items order
-
-+-----------------+
-|...........PS=>..|
-+-----------------+
-
-S: Initial iterator position
-P: Iterator position
-```
-
-Iterate over the buffer, wrapping once until reaching `P` where in this
-case `done` is set, and iterator ends at the following `next()`.
-
-*/
-#[derive(Debug, Clone)]
-pub struct RoundRobinIterator<'a, T: Sized> {
-    /// Round-robin buffer being iterated.
-    rrb: &'a RoundRobinBuffer<T>,
-
-    /// Position of the iterator in the buffer.
-    pos: usize,
-
-    /// Indicate if the iterator has completed.
-    /// We need this as self.rrb.pos contains valid information so we can't rely on `self.pos == self.rrb.pos`
-    /// to report end; and we don't want to discard this value.
-    done: bool,
-}
-
-impl<'a, T: Sized> Iterator for RoundRobinIterator<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.done {
-            return None;
-        }
-
-        let value = &self.rrb.buffer[self.pos];
-
-        self.pos = (self.pos + 1) % self.rrb.size;
-
-        if self.pos == self.rrb.pos {
-            self.done = true;
-        }
-
-        Some(value)
-    }
-
-    /**
-      # Design
-
-      ```plain
-      * I < B
-      +-----------------+
-      |.....I.....B.....|
-      +-----------------+
-
-      'I' already wrapped arround, so B - I + 1 is remaining count (include element at B).
-
-      * I > B
-      +-----------------+
-      |.....B.....I.....|
-      +-----------------+
-
-      'I' haven't wrapped arround, so size - I + B + 1 (include element at B) is remaining.
-
-      * I = B
-
-      0 if done, 1 otherwise
-
-      I: Buffer position
-      B: Iterator position
-      ```
-    */
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let remaining = if self.pos < self.rrb.pos {
-            self.rrb.pos - self.pos + 1
-        } else if self.pos > self.rrb.pos {
-            self.rrb.size - self.pos + self.rrb.pos + 1
-        } else if self.done {
-            0
-        } else {
-            1
-        };
-
-        (remaining, Some(remaining))
-    }
-}
-
-#[test]
-fn round_robin_test_insert() {
-    let mut buffer = RoundRobinBuffer::new(32, f64::NAN);
-    assert!(f64::is_nan(*buffer.iter().next().unwrap()));
-
-    // Add 32 elements into the buffer.
-    (0..32).for_each(|i| buffer.push(i as f64));
-
-    // Elements should come in the same order (we filled the buffer).
-    (0..32).zip(buffer.iter()).for_each(|(reference, val)| {
-        assert_eq!(reference, *val as i32);
-    });
-
-    // Overwrite all elements.
-    (32..64).for_each(|i| buffer.push(i as f64));
-
-    (32..64).zip(buffer.iter()).for_each(|(reference, val)| {
-        assert_eq!(reference, *val as i32);
-    });
-}
-
-#[test]
-fn round_robin_test_iter_count() {
-    let buffer = RoundRobinBuffer::new(32, f64::NAN);
-    assert_eq!(buffer.iter().count(), 32);
-
-    let buffer = RoundRobinBuffer::new(1, f64::NAN);
-    assert_eq!(buffer.iter().count(), 1);
-}
diff --git a/xcp-metrics/src/publishers/rrdd/server.rs b/xcp-metrics/src/publishers/rrdd/server.rs
deleted file mode 100644
index 981562e..0000000
--- a/xcp-metrics/src/publishers/rrdd/server.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-//! [RrddServer] implementation
-use std::{
-    collections::HashMap,
-    iter,
-    sync::Arc,
-    time::{Duration, SystemTime},
-};
-use tokio::{self, select, sync::mpsc, task::JoinHandle};
-
-use xcp_metrics_common::{
-    metrics::{Metric, MetricFamily, MetricSet, MetricType, MetricValue, NumberValue},
-    rrdd::{
-        protocol_common::{DataSourceMetadata, DataSourceOwner},
-        rrd_updates::RrdXport,
-    },
-    utils::mapping::{CustomMapping, DefaultMapping, MetadataMapping},
-};
-
-use super::{entry::RrdEntry, Granuality, RrdXportFilter, RrdXportParameters};
-
-use crate::hub::{HubPullResponse, HubPushMessage, PullMetrics};
-
-/// Types of message to communicate with [RrddServer].
-#[derive(Debug)]
-pub enum RrddServerMessage {
-    RequestRrdUpdates(RrdXportParameters, mpsc::Sender<anyhow::Result<RrdXport>>),
-}
-
-/// xcp-rrdd partially compatible server that stores the state of metrics over time.
-///
-/// See [super] for more information.
-#[derive(Debug)]
-pub struct RrddServer {
-    receiver: mpsc::UnboundedReceiver<RrddServerMessage>,
-    host_uuid: uuid::Uuid,
-    mappings: HashMap<Box<str>, CustomMapping>,
-
-    /// Map a UUID from hub's MetricSet with a RrdEntry.
-    entry_database: HashMap<uuid::Uuid, RrdEntry>,
-
-    latest_update: SystemTime,
-
-    minute_update_counter: u32,
-    latest_minute_update: SystemTime,
-
-    hour_update_counter: u32,
-    latest_hour_update: SystemTime,
-
-    day_update_counter: u32,
-    latest_day_update: SystemTime,
-}
-
-/// Get the owner part of the rrd name (i.e vm:UUID).
-fn format_owner_part(metadata: &DataSourceMetadata, host_uuid: uuid::Uuid) -> String {
-    match metadata.owner {
-        DataSourceOwner::Host => format!("host:{host_uuid}"),
-        DataSourceOwner::VM(uuid) => format!("vm:{uuid}"),
-        DataSourceOwner::SR(uuid) => format!("sr:{uuid}"),
-    }
-}
-
-impl RrddServer {
-    pub fn new(
-        mappings: HashMap<Box<str>, CustomMapping>,
-    ) -> (Self, mpsc::UnboundedSender<RrddServerMessage>) {
-        let (sender, receiver) = mpsc::unbounded_channel();
-
-        (
-            Self {
-                receiver,
-                host_uuid: uuid::Uuid::new_v4(),
-                mappings,
-
-                entry_database: HashMap::new(),
-
-                latest_update: SystemTime::now(),
-
-                day_update_counter: 0,
-                latest_day_update: SystemTime::now(),
-
-                hour_update_counter: 0,
-                latest_hour_update: SystemTime::now(),
-
-                minute_update_counter: 0,
-                latest_minute_update: SystemTime::now(),
-            },
-            sender,
-        )
-    }
-
-    fn to_name_v2(
-        mappings: &HashMap<Box<str>, CustomMapping>,
-        metric: &Metric,
-        family: &MetricFamily,
-        family_name: &str,
-    ) -> Option<(Box<str>, DataSourceMetadata)> {
-        if let Some(custom_mapping) = mappings.get(family_name) {
-            custom_mapping.convert(family_name, family, metric)
-        } else {
-            DefaultMapping.convert(family_name, family, metric)
-        }
-    }
-
-    /// Pull metrics from hub
-    pub async fn pull_metrics(
-        &mut self,
-        hub_channel: &mpsc::UnboundedSender<HubPushMessage>,
-    ) -> anyhow::Result<Arc<MetricSet>> {
-        let (tx, mut rx) = mpsc::unbounded_channel();
-        hub_channel.send(HubPushMessage::PullMetrics(PullMetrics(tx)))?;
-
-        let response = rx.recv().await.ok_or(anyhow::anyhow!("No response"))?;
-
-        match response {
-            HubPullResponse::Metrics(metrics) => Ok(metrics), //r => tracing::error!("Unsupported hub response: {r:?}"),
-        }
-    }
-
-    /// Update all metrics
-    pub fn update_metrics(&mut self, metrics: &MetricSet) {
-        let do_update_minute = {
-            self.minute_update_counter =
-                (self.minute_update_counter + 1) % Granuality::Minute.get_five_seconds_interval();
-            self.minute_update_counter == 0
-        };
-
-        let do_update_hour = {
-            self.hour_update_counter =
-                (self.hour_update_counter + 1) % Granuality::Hour.get_five_seconds_interval();
-            self.hour_update_counter == 0
-        };
-
-        let do_update_day = {
-            self.day_update_counter =
-                (self.day_update_counter + 1) % Granuality::Day.get_five_seconds_interval();
-            self.day_update_counter == 0
-        };
-
-        // TODO: Take in account removed metrics, as they will no longer exist in latest MetricSet.
-        // Maybe use a MetricSetModel to track added metrics, and rely on entry_database to iterate ?
-        metrics
-            .families
-            .iter()
-            .filter(|(_, family)| {
-                // Only consider gauge and counter metrics.
-                matches!(family.metric_type, MetricType::Gauge | MetricType::Counter)
-            })
-            .flat_map(|(name, family)| {
-                iter::zip(iter::repeat((name, family)), family.metrics.iter())
-            })
-            .for_each(|((family_name, family), (&uuid, metric))| {
-                self.do_update_metric(
-                    uuid,
-                    metric,
-                    family,
-                    family_name,
-                    do_update_minute,
-                    do_update_hour,
-                    do_update_day,
-                )
-            });
-    }
-
-    /// Update the metric in the entry database.
-    fn do_update_metric(
-        &mut self,
-        uuid: uuid::Uuid,
-        metric: &Metric,
-        family: &MetricFamily,
-        family_name: &str,
-        do_update_minute: bool,
-        do_update_hour: bool,
-        do_update_day: bool,
-    ) {
-        // Get (or create) the entry.
-        let entry = self.entry_database.entry(uuid).or_insert_with(|| {
-            tracing::debug!("New entry {uuid}");
-            let (v2_name, metadata) = Self::to_name_v2(&self.mappings, metric, family, family_name)
-                .expect("Unexpected to_name_v2 failure");
-            let owner_part = format_owner_part(&metadata, self.host_uuid);
-
-            // Consider only AVERAGE metrics for now.
-            RrdEntry::new(
-                format!("AVERAGE:{owner_part}:{v2_name}").into_boxed_str(),
-                metadata,
-            )
-        });
-
-        // Take the first metric.
-        let first_metric = metric
-            .metrics_point
-            .first()
-            .map(|metric_point| &metric_point.value);
-
-        // Get the value as f64, use NaN is nothing is available.
-        let value = first_metric.map_or(f64::NAN, |metric| match metric {
-            MetricValue::Gauge(value) | MetricValue::Counter { total: value, .. } => match *value {
-                NumberValue::Double(val) => val,
-                NumberValue::Int64(val) => val as _,
-                NumberValue::Undefined => f64::NAN,
-            },
-            _ => f64::NAN,
-        });
-
-        entry.five_seconds.push(value);
-
-        if do_update_minute {
-            self.latest_minute_update = SystemTime::now();
-            entry.minute.push(value);
-        }
-
-        if do_update_hour {
-            self.latest_hour_update = SystemTime::now();
-            entry.hour.push(value);
-        }
-
-        if do_update_day {
-            self.latest_day_update = SystemTime::now();
-            entry.day.push(value);
-        }
-    }
-
-    pub async fn process_message(&self, message: RrddServerMessage) {
-        match message {
-            RrddServerMessage::RequestRrdUpdates(info, sender) => {
-                tracing::info!("Processing RrdUpdate request");
-
-                // TODO: Use interval.
-
-                let granuality = {
-                    let distance_from_now = info.start.elapsed().unwrap_or(
-                        Duration::ZERO, /* if start is in the future, consider now */
-                    );
-
-                    if distance_from_now < Granuality::FiveSeconds.get_covered_duration() {
-                        Granuality::FiveSeconds
-                    } else if distance_from_now < Granuality::Minute.get_covered_duration() {
-                        Granuality::Minute
-                    } else if distance_from_now < Granuality::Hour.get_covered_duration() {
-                        Granuality::Hour
-                    } else {
-                        Granuality::Day
-                    }
-                };
-
-                let (legend, mut data_iterators): (Vec<_>, Vec<_>) = self
-                    .entry_database
-                    .values()
-                    .filter(|entry| {
-                        // Apply filter
-                        match info.filter {
-                            RrdXportFilter::All => true,
-                            RrdXportFilter::AllNoHost => !matches!(entry.metadata.owner, DataSourceOwner::Host),
-                            RrdXportFilter::VM(uuid) => matches!(entry.metadata.owner, DataSourceOwner::VM(entry_uuid) if uuid == entry_uuid),
-                            RrdXportFilter::SR(uuid) => matches!(entry.metadata.owner, DataSourceOwner::SR(entry_uuid) if uuid == entry_uuid),
-                        }
-                    })
-                    .map(|entry| (entry.name.clone(), entry.get_buffer(granuality).iter()))
-                    .unzip();
-
-                let (start, end) = {
-                    let start = match granuality {
-                        Granuality::FiveSeconds => self.latest_update,
-                        Granuality::Minute => self.latest_minute_update,
-                        Granuality::Hour => self.latest_hour_update,
-                        Granuality::Day => self.latest_day_update,
-                    };
-
-                    (start, start + granuality.get_covered_duration())
-                };
-
-                let data = (0..granuality.get_buffer_size())
-                    .map(|i| {
-                        (
-                            start + (i as u32) * granuality.get_interval(),
-                            data_iterators
-                                .iter_mut()
-                                .map(|iter| iter.next().unwrap_or(&f64::NAN))
-                                .cloned()
-                                .collect(),
-                        )
-                    })
-                    .collect();
-
-                sender
-                    .send(Ok(RrdXport {
-                        start,
-                        end,
-                        step_secs: granuality.get_five_seconds_interval() * 5,
-                        legend,
-                        data,
-                    }))
-                    .await
-                    .unwrap();
-            }
-        }
-    }
-
-    #[tracing::instrument]
-    pub fn start(mut self, hub_channel: mpsc::UnboundedSender<HubPushMessage>) -> JoinHandle<()> {
-        tokio::task::spawn(async move {
-            let mut timer = tokio::time::interval(Duration::from_secs(5));
-
-            loop {
-                select! {
-                    _ = timer.tick() => {
-                        tracing::debug!("Pulling metrics");
-
-                        match self.pull_metrics(&hub_channel).await {
-                            Ok(metrics) => self.update_metrics(&metrics),
-                            Err(e) => tracing::error!("Unable to pull metrics {e}")
-                        }
-                    },
-                    msg = self.receiver.recv() => {
-                        match msg {
-                            Some(msg) => self.process_message(msg).await,
-                            None => tracing::error!("Unable to read channel message")
-                        }
-                    }
-                }
-            }
-        })
-    }
-}
diff --git a/xcp-metrics/src/rpc.rs b/xcp-metrics/src/rpc.rs
new file mode 100644
index 0000000..fe66f98
--- /dev/null
+++ b/xcp-metrics/src/rpc.rs
@@ -0,0 +1,81 @@
+//! RPC metrics path.
+//!
+//! TODO: Deal with disconnected clients.
+//!       Track metrics families.
+
+use std::path::Path;
+
+use tokio::{
+    net::{UnixListener, UnixStream},
+    sync::{mpsc, oneshot},
+    task,
+};
+use xcp_metrics_common::{
+    openmetrics::{self, prost::Message},
+    protocol::{FetchMetrics, ProtocolMessage, XcpMetricsAsyncStream},
+};
+
+use crate::hub::{HubPullResponse, HubPushMessage, PullMetrics};
+
+async fn rpc_session(
+    mut stream: UnixStream,
+    hub: mpsc::UnboundedSender<HubPushMessage>,
+) -> anyhow::Result<()> {
+    loop {
+        let message = stream.recv_message_async().await?;
+        tracing::debug!("Received {message:?}");
+
+        match message {
+            ProtocolMessage::CreateFamily(create_family) => {
+                hub.send(HubPushMessage::CreateFamily(create_family))?
+            }
+            ProtocolMessage::RemoveFamily(remove_family) => {
+                hub.send(HubPushMessage::RemoveFamily(remove_family))?
+            }
+            ProtocolMessage::UpdateMetric(update_metric) => {
+                hub.send(HubPushMessage::UpdateMetric(update_metric))?
+            }
+            ProtocolMessage::RemoveMetric(remove_metric) => {
+                hub.send(HubPushMessage::RemoveMetric(remove_metric))?
+            }
+
+            ProtocolMessage::FetchMetrics(fetch_metrics) => {
+                // Get metrics from hub
+                let (sender, receiver) = oneshot::channel();
+                hub.send(HubPushMessage::PullMetrics(PullMetrics(sender)))?;
+
+                let HubPullResponse::Metrics(metrics_set) = receiver.await?;
+
+                match fetch_metrics {
+                    FetchMetrics::OpenMetrics1 => {
+                        let mut buffer = String::new();
+                        openmetrics::text::write_metrics_set_text(&mut buffer, &metrics_set)?;
+
+                        stream.send_message_raw_async(buffer.as_bytes()).await?;
+                    }
+                    FetchMetrics::OpenMetrics1Binary => {
+                        let buffer =
+                            openmetrics::MetricSet::from((*metrics_set).clone()).encode_to_vec();
+
+                        stream.send_message_raw_async(&buffer).await?;
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub async fn run(path: &Path, hub: mpsc::UnboundedSender<HubPushMessage>) -> anyhow::Result<()> {
+    let listener = UnixListener::bind(path)?;
+
+    loop {
+        let (stream, _) = listener.accept().await?;
+        let hub = hub.clone();
+
+        task::spawn(async move {
+            if let Err(e) = rpc_session(stream, hub).await {
+                tracing::error!("RPC session error: {e}");
+            }
+        });
+    }
+}
diff --git a/xcp-metrics/src/rpc/mod.rs b/xcp-metrics/src/rpc/mod.rs
deleted file mode 100644
index c4852a7..0000000
--- a/xcp-metrics/src/rpc/mod.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//! RPC routes and daemon..
-pub mod routes;
-
-use std::{convert::Infallible, path::Path, sync::Arc};
-
-use http::{Request, Response, StatusCode};
-use http_body::Body;
-use http_body_util::Full;
-use hyper::{body::Bytes, server::conn::http1, service::service_fn};
-use hyper_util::rt::TokioIo;
-use tokio::{
-    net::UnixListener,
-    task::{self, JoinHandle},
-};
-
-use xapi::rpc::{self};
-
-use crate::XcpMetricsShared;
-
-const MAX_BODY_LEN: u32 = 2 * 1024 * 1024; // 2 MB
-
-fn build_response(status: StatusCode, body: &str) -> Response<Full<Bytes>> {
-    Response::builder()
-        .status(status)
-        .body(Full::new(body.to_string().into()))
-        .unwrap()
-}
-
-async fn request_handler<B: Body>(
-    shared: Arc<XcpMetricsShared>,
-    request: Request<B>,
-) -> anyhow::Result<Response<Full<Bytes>>>
-where
-    <B as Body>::Error: std::fmt::Display,
-{
-    if let Some(header) = request.headers().get("content-length") {
-        let header_len: u32 = header.to_str()?.parse()?;
-
-        if header_len > MAX_BODY_LEN {
-            tracing::error!("Got too large payload {header_len} > {MAX_BODY_LEN}");
-
-            return Ok(build_response(
-                StatusCode::PAYLOAD_TOO_LARGE,
-                "Content Too Large",
-            ));
-        }
-    } else {
-        tracing::error!("Got response without content-length");
-
-        return Ok(build_response(
-            StatusCode::BAD_REQUEST,
-            "No content-length provided",
-        ));
-    }
-
-    let rpc_request = rpc::message::parse_http_request(request).await?;
-
-    Ok(routes::dispatch(shared, rpc_request).await.map(Full::new))
-}
-
-pub async fn entrypoint<B: Body>(
-    shared: Arc<XcpMetricsShared>,
-    request: Request<B>,
-) -> Result<Response<Full<Bytes>>, Infallible>
-where
-    <B as Body>::Error: std::fmt::Display,
-{
-    Ok(request_handler(shared, request)
-        .await
-        .inspect_err(|e| tracing::error!("Internal Server Error: {e}"))
-        .unwrap_or_else(|_| {
-            build_response(StatusCode::INTERNAL_SERVER_ERROR, "Internal Server Error")
-        }))
-}
-
-pub async fn start_daemon(
-    daemon_path: &Path,
-    shared: Arc<XcpMetricsShared>,
-) -> anyhow::Result<JoinHandle<()>> {
-    let unix_stream = UnixListener::bind(daemon_path)?;
-
-    Ok(task::spawn(async move {
-        loop {
-            let shared = shared.clone();
-            let (stream, addr) = unix_stream.accept().await.unwrap();
-            tracing::info!("Client {addr:?} connected");
-
-            // Wait for socket to be ready.
-            //future::poll_fn(|cx| stream.poll_read_ready(cx)).await.unwrap();
-
-            let io = TokioIo::new(stream);
-
-            tokio::task::spawn(async move {
-                if let Err(err) = http1::Builder::new()
-                    .serve_connection(io, service_fn(|body| entrypoint(shared.clone(), body)))
-                    .await
-                {
-                    tracing::error!("Error servicing connection {addr:?}: {err:?}");
-                }
-            });
-        }
-    }))
-}
diff --git a/xcp-metrics/src/rpc/routes/deregister.rs b/xcp-metrics/src/rpc/routes/deregister.rs
deleted file mode 100644
index 79b3df8..0000000
--- a/xcp-metrics/src/rpc/routes/deregister.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! RPC route for `Plugin.Local.deregister`.
-use std::sync::Arc;
-
-use http::Response;
-use xapi::rpc::{
-    message::{request::RpcRequest, response::RpcResponse},
-    methods::rrdd::PluginLocalDeregister,
-};
-
-use crate::XcpMetricsShared;
-
-pub async fn run(
-    shared: Arc<XcpMetricsShared>,
-    request: RpcRequest,
-) -> anyhow::Result<Response<String>> {
-    let deregister_rpc: PluginLocalDeregister = request
-        .clone()
-        .try_into_method()
-        .ok_or_else(|| anyhow::anyhow!("No value provided"))?;
-
-    if let Some((name, handle)) = shared.plugins.remove(deregister_rpc.uid.as_str()) {
-        tracing::info!("RPC: Unregistered {name}");
-
-        handle.abort();
-    }
-
-    RpcResponse::respond_to(&request, "Done")
-}
diff --git a/xcp-metrics/src/rpc/routes/get_formats.rs b/xcp-metrics/src/rpc/routes/get_formats.rs
deleted file mode 100644
index b1225e8..0000000
--- a/xcp-metrics/src/rpc/routes/get_formats.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! RPC route for `Plugin.Metrics.get_formats`.
-use std::sync::Arc;
-
-use http::Response;
-use xapi::rpc::{
-    message::{request::RpcRequest, response::RpcResponse},
-    response::rrdd::PluginMetricsVersionsResponse,
-};
-
-use crate::XcpMetricsShared;
-
-pub async fn run(
-    _shared: Arc<XcpMetricsShared>,
-    request: RpcRequest,
-) -> anyhow::Result<Response<String>> {
-    RpcResponse::respond_to(
-        &request,
-        PluginMetricsVersionsResponse {
-            versions: vec!["OpenMetrics 1.0.0".to_string()],
-        },
-    )
-}
diff --git a/xcp-metrics/src/rpc/routes/mod.rs b/xcp-metrics/src/rpc/routes/mod.rs
deleted file mode 100644
index fc62ec1..0000000
--- a/xcp-metrics/src/rpc/routes/mod.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-//! RPC routes
-mod deregister;
-mod get_formats;
-mod next_reading;
-mod register;
-mod register_v3;
-
-use std::sync::Arc;
-
-use http::Response;
-use hyper::body::Bytes;
-use xapi::rpc::message::{error::RpcError, request::RpcRequest};
-
-use crate::{publishers::openmetrics, XcpMetricsShared};
-
-fn make_binary(response: Response<String>) -> Response<Bytes> {
-    // Convert inner String to Bytes.
-    response.map(Into::into)
-}
-
-pub async fn dispatch(shared: Arc<XcpMetricsShared>, request: RpcRequest) -> Response<Bytes> {
-    tracing::info!("RPC Message: {request}");
-
-    let res = match request.get_name() {
-        "OpenMetrics" => openmetrics::run(shared, request).await,
-        "Plugin.Local.register" => register::run(shared, request).await.map(make_binary),
-        "Plugin.Local.deregister" => deregister::run(shared, request).await.map(make_binary),
-        "Plugin.Local.next_reading" => next_reading::run(shared, request).await.map(make_binary),
-        "Plugin.Metrics.get_versions" => get_formats::run(shared, request).await.map(make_binary),
-        "Plugin.Metrics.register" => register_v3::run(shared, request).await.map(make_binary),
-        "Plugin.Metrics.deregister" => deregister::run(shared, request).await.map(make_binary),
-        _ => {
-            tracing::error!("RPC Method not found: {request}");
-            RpcError::respond_to::<()>(Some(&request), -32601, "Method not found", None)
-                .map(make_binary)
-        }
-    };
-
-    match res {
-        Ok(res) => res,
-        Err(e) => {
-            tracing::error!("Internal error: {e}");
-
-            Response::builder()
-                .status(http::StatusCode::INTERNAL_SERVER_ERROR)
-                .body("Internal Server Error".into())
-                .expect("Unable to make error 500")
-        }
-    }
-}
diff --git a/xcp-metrics/src/rpc/routes/next_reading.rs b/xcp-metrics/src/rpc/routes/next_reading.rs
deleted file mode 100644
index 36d231b..0000000
--- a/xcp-metrics/src/rpc/routes/next_reading.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! RPC route for `Plugin.Local.next_reading`.
-use std::sync::Arc;
-
-use http::Response;
-use xapi::rpc::message::{request::RpcRequest, response::RpcResponse};
-
-use crate::XcpMetricsShared;
-
-#[derive(Clone, Copy, Default)]
-pub struct PluginLocalNextReadingRoute;
-
-pub async fn run(
-    _shared: Arc<XcpMetricsShared>,
-    request: RpcRequest,
-) -> anyhow::Result<Response<String>> {
-    RpcResponse::respond_to(
-        &request, /* next_reading: */ 5.0, /* Same as register */
-    )
-}
diff --git a/xcp-metrics/src/rpc/routes/register.rs b/xcp-metrics/src/rpc/routes/register.rs
deleted file mode 100644
index 8ac0d73..0000000
--- a/xcp-metrics/src/rpc/routes/register.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! RPC route for `Plugin.Local.register`.
-use std::sync::Arc;
-
-use http::Response;
-use xapi::rpc::{
-    message::{error::RpcError, request::RpcRequest, response::RpcResponse},
-    methods::rrdd::PluginLocalRegister,
-};
-
-use crate::{
-    providers::{protocol_v2::ProtocolV2Provider, protocol_v3::ProtocolV3Provider, Provider},
-    XcpMetricsShared,
-};
-
-pub async fn run(
-    shared: Arc<XcpMetricsShared>,
-    request: RpcRequest,
-) -> anyhow::Result<Response<String>> {
-    let register_rpc: PluginLocalRegister = request
-        .clone()
-        .try_into_method()
-        .ok_or_else(|| anyhow::anyhow!("No value provided"))?;
-
-    if shared // check if plugin exists and is active
-        .plugins
-        .get(register_rpc.uid.as_str())
-        .map(|handle| !handle.is_finished())
-        .is_none()
-    {
-        let plugin_handle = match register_rpc.protocol.as_str() {
-            "V2" => {
-                tracing::info!(uid = register_rpc.uid, "Starting protocol v2 provider");
-                ProtocolV2Provider::new(&register_rpc.uid)
-                    .start_provider(shared.hub_channel.clone())
-            }
-            "V3" => {
-                tracing::info!(uid = register_rpc.uid, "Starting protocol v3 provider");
-                ProtocolV3Provider::new(&register_rpc.uid)
-                    .start_provider(shared.hub_channel.clone())
-            }
-            _ => {
-                return RpcError::respond_to(
-                    Some(&request),
-                    -32000,
-                    "Unknown or unsupported protocol",
-                    Some(register_rpc.protocol),
-                );
-            }
-        };
-
-        shared
-            .plugins
-            .insert(register_rpc.uid.into(), plugin_handle);
-    } else {
-        tracing::warn!(
-            "Attempted to register an already registered plugin {}",
-            register_rpc.uid
-        );
-    }
-
-    RpcResponse::respond_to(
-        &request,
-        /* next_reading: */
-        5.0, /* all provider readings are independant, thus this is always 5 */
-    )
-}
diff --git a/xcp-metrics/src/rpc/routes/register_v3.rs b/xcp-metrics/src/rpc/routes/register_v3.rs
deleted file mode 100644
index 1ae083e..0000000
--- a/xcp-metrics/src/rpc/routes/register_v3.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! RPC route for `Plugin.Metrics.register_v3`.
-use std::sync::Arc;
-
-use http::Response;
-use xapi::rpc::{
-    message::{error::RpcError, request::RpcRequest, response::RpcResponse},
-    methods::rrdd::PluginMetricsRegister,
-};
-
-use crate::{
-    providers::{protocol_v3::ProtocolV3Provider, Provider},
-    XcpMetricsShared,
-};
-
-pub async fn run(
-    shared: Arc<XcpMetricsShared>,
-    request: RpcRequest,
-) -> anyhow::Result<Response<String>> {
-    let register_rpc: PluginMetricsRegister = request
-        .clone()
-        .try_into_method()
-        .ok_or_else(|| anyhow::anyhow!("No value provided"))?;
-
-    if register_rpc.version != "OpenMetrics 1.0.0" {
-        return RpcError::respond_to(
-            Some(&request),
-            -32000,
-            "Unsupported OpenMetrics version",
-            Some(register_rpc.version),
-        );
-    }
-
-    if shared // check if plugin exists and is active
-        .plugins
-        .get(register_rpc.uid.as_str())
-        .map(|handle| !handle.is_finished())
-        .is_none()
-    {
-        tracing::info!(uid = register_rpc.uid, "Starting protocol v3 provider");
-        let plugin_handle =
-            ProtocolV3Provider::new(&register_rpc.uid).start_provider(shared.hub_channel.clone());
-
-        shared
-            .plugins
-            .insert(register_rpc.uid.into(), plugin_handle);
-    } else {
-        tracing::warn!(
-            "Attempted to register an already registered plugin {}",
-            register_rpc.uid
-        );
-    }
-
-    RpcResponse::respond_to(&request, "OK")
-}