implementations of encode_family on text & protobuf are not symmetric

[codefever]

For text (https://github.com/prometheus/client_rust/blob/master/src/encoding/text.rs#L387), family inheritance is prohibited by debug_assert.
But for protobuf (https://github.com/prometheus/client_rust/blob/master/src/encoding/protobuf.rs#L236), the iniheritantce is allowed.

Is there any special consideration? I found these when i was implementing a custom metric which would extend its own families under another prometheus_client::metrics::family::Family context.

[mxinden]

If I recall correctly, I disallowed a family in a family back then, to prevent edge cases.

What is your use-case for a family in a family?

[codefever]

If I recall correctly, I disallowed a family in a family back then, to prevent edge cases.

What is your use-case for a family in a family?

I wanted to implement a custom metric type which generate multiple metrics out with different prefix and labels (Like histogram).

After a deeper look at Summary type, I thought it quitely matches my use case. However, there's no Summary supported in this crate. I've seen several PRs here. What're the blocking issues about them...

[drbrain]

Allowing nesting Family in Family for both encoders allows space-savings. Instead of dragging around all the references to create a label users can rely on the prometheus_client registry to store this information and only have to store the inner Family.

A non-nested Family allows this with a metric set like:

struct HTTPServerMetrics {
    /// Requests started
    requests: Family<Method, Counter>,
    /// Responses sent without error
    responses: Family<Method, Counter>,
    /// Error responses
    errors: Family<Method, Counter>,
}

fn handle_request(req: &Request, metrics: &HTTPServerMetrcis) -> Response {
    let method = req.get_method();

    // We can count the request now because we received it
    metrics.requests.get_or_create(&method).inc();

    // fetch the Counter with labels attached for responses and errors for use in dispatch_to_routing()
    let responses = metrics.responses.get_or_create(&method).clone();
    let errors = metrics.errors.get_or_create(&method).clone();

    dispatch_to_routing(req, responses, errors)
}

I want to use nested metrics when I have a metric with both a static label and a dynamic label, and don't want to carry around the information about what type of label I need to construct. I can specialize the metric through Family::get_or_create() on the components of the complete label.

Here's an example I would like to use with text output:

enum TypeLabel {
    Configured,
    Healthy,
}

impl EncodeLabelSet for TypeLabel { … }
impl EncodeLabelValue for TypeLabel { … }

/// Request type
struct ClusterName {
    name: String,
}

impl EncodeLabelSet for ClusterName { … }
impl EncodeLabelValue for ClusterName { … }

The metric is defined as a nested family, but the static labels are immediately resolved during registration:

struct ClusterMembers {
    configured: Family<ClusterName, Gauge>,
    healthy: Family<ClusterName, Gauge>,
}

impl ClusterMembers {
    fn new(registry: &mut Registry) -> Self {
        let cluster_members = Family::<TypeLabels, Family<ClusterName, Gauge>>::default();

        let configured = cluster_members.get_or_create(&TypeLabels::Configured).clone();
        let healthy = cluster_members.get_or_create(&TypeLabels::Healthy).clone();

        registry.register("cluster_members", "Cluster membership status", cluster_members);

        Self { configured, healthy }
    }
}

When the cluster config is loaded I specialize again:

let metrics = ClusterMembers::new(&mut registry);

// … in some other function …

let cluster_config = load_cluster_config()?;

let configured = metrics.configured.get_or_create(&ClusterName { name: cluster_config.name() }).set(cluster_config.members.len());
let healthy = metrics.configured.get_or_create(&ClusterName { name: cluster_config.name.to_string()}).clone();

start_health_check_task(cluster_config, healthy);

Where the start_health_check_task() function will update healthy which is a Gauge and doesn't need to know the cluster name or type of metric it is so I don't have to carry that data around.

The output would be:

cluster_members{type="configured",cluster="CLUSTER-A"} 50
cluster_members{type="healthy",cluster="CLUSTER-B"} 48

Where the type="configured" metric updates when the cluster configuration is reset and the type="healthy" is updated when health checks are periodically checked

[mxinden]

Do I understand correctly that you could not achieve this via Registry::sub_registry_with_prefix? If yes, can you please explain?

client_rust/src/registry.rs

Lines 210 to 244 in 3942d06

	/// Create a sub-registry to register metrics with a common prefix.
	///
	/// Say you would like to prefix one set of metrics with `subsystem_a` and
	/// one set of metrics with `subsystem_b`. Instead of prefixing each metric
	/// with the corresponding subsystem string individually, you can create two
	/// sub-registries like demonstrated below.
	///
	/// This can be used to pass a prefixed sub-registry down to a subsystem of
	/// your architecture automatically adding a prefix to each metric the
	/// subsystem registers.
	///
	/// ```
	/// # use prometheus_client::metrics::counter::{Atomic as _, Counter};
	/// # use prometheus_client::registry::{Registry, Unit};
	/// #
	/// let mut registry = Registry::default();
	///
	/// let subsystem_a_counter_1: Counter = Counter::default();
	/// let subsystem_a_counter_2: Counter = Counter::default();
	///
	/// let subsystem_a_registry = registry.sub_registry_with_prefix("subsystem_a");
	/// subsystem_a_registry.register("counter_1", "", subsystem_a_counter_1.clone());
	/// subsystem_a_registry.register("counter_2", "", subsystem_a_counter_2.clone());
	///
	/// let subsystem_b_counter_1: Counter = Counter::default();
	/// let subsystem_b_counter_2: Counter = Counter::default();
	///
	/// let subsystem_b_registry = registry.sub_registry_with_prefix("subsystem_b");
	/// subsystem_b_registry.register("counter_1", "", subsystem_b_counter_1.clone());
	/// subsystem_b_registry.register("counter_2", "", subsystem_b_counter_2.clone());
	/// ```
	///
	/// See [`Registry::sub_registry_with_label`] for the same functionality,
	/// but namespacing with a label instead of a metric name prefix.
	pub fn sub_registry_with_prefix<P: AsRef<str>>(&mut self, prefix: P) -> &mut Self {