My Metrics are not getting published

[r0wdiggity]

I have an app and I am trying to publish metrics. I have logging around it, and I can see that the metrics are getting created, but every time the publish function is called, it outputs "published 0 metrics" and indeed Prometheus has no app metrics, but I can see the scraper queries against the service. I left both in the code to show that I tried both a global meter provider, as well as using the provider to create a meter. Any help would be greatly appreciated!

pub struct Metrics {
    pub meter: Meter,
    pub registry: prometheus::Registry,
    enabled: bool,
}

impl Default for Metrics {
    fn default() -> Self {
        Self::new()
    }
}

impl Metrics {
    pub fn new() -> Self {
        // meter examples: https://github.com/open-telemetry/opentelemetry-rust/blob/main/examples/metrics-basic/src/main.rs
        let enabled =
            env::var("OTEL_METRICS_ENABLED").unwrap_or_else(|_| "false".to_string()) == "true";
        if enabled {
            let registry = prometheus::Registry::new();
            let exporter = opentelemetry_prometheus::exporter()
                .with_registry(registry.clone())
                .with_namespace("reporting")
                .build()
                .expect("Failed to create Prometheus exporter");

            let resource = Resource::builder_empty()
                .with_attributes([KeyValue::new("service.name", "reporting")])
                .build();

            let provider = SdkMeterProvider::builder()
                .with_reader(exporter)
                .with_resource(resource)
                .build();

            global::set_meter_provider(provider.clone());
            let meter = provider.meter("reporting");
            Self {
                meter,
                registry,
                enabled,
            }
        } else {
            let provider = SdkMeterProvider::default();
            let meter = provider.meter("reporting");
            let registry = prometheus::Registry::new();
            global::set_meter_provider(provider.clone());
            Self {
                meter,
                registry,
                enabled,
            }
        }
    }

    pub fn incr_counter(
        &self,
        counter_name: String,
        value: u64,
        attributes: Option<Vec<KeyValue>>,
    ) {
        if !self.enabled {
            return;
        }
        info!("Adding to counter: {}", counter_name);
        let meter = global::meter("reporting");
        let counter = meter.u64_counter(counter_name).build();
        let attributes_vec = attributes.unwrap_or_default();
        counter.add(value, &attributes_vec);
        info!("Added to counter: {:?}", counter);
    }

    pub fn add_to_timer(&self, timer_name: String, value: f64, attributes: Option<Vec<KeyValue>>) {
        if !self.enabled {
            return;
        }
        info!("Adding to timer: {}", timer_name);
        let timer = self.meter.f64_histogram(timer_name).build();
        let attributes_vec = attributes.unwrap_or_default();
        timer.record(value, &attributes_vec);
        info!("Added to timer: {:?}", timer);
    }

    pub fn publish(&self) -> Result<Vec<u8>> {
        if !self.enabled {
            return Ok(Vec::new());
        }
        let mut result = Vec::new();
        let encoder = prometheus::TextEncoder::new();
        let metrics = self.registry.gather();
        encoder.encode(&metrics, &mut result)?;
        info!("published {} metrics", metrics.len());
        Ok(result)
    }

    async fn metrics_handler(
        &self,
        req: Request<hyper::body::Incoming>,
    ) -> Result<Response<Full<Bytes>>> {
        if !self.enabled {
            return Ok(Response::builder()
                .status(StatusCode::NOT_FOUND)
                .body(Full::new(Bytes::from("Metrics not enabled")))
                .unwrap());
        }
        match req.uri().path() {
            "/metrics" => {
                info!("Serving metrics");
                let metrics = self.publish()?;
                info!("Metrics: {}", String::from_utf8_lossy(&metrics));
                let body = Full::new(Bytes::from(metrics));
                let response = Response::builder()
                    .status(StatusCode::OK)
                    .header("Content-Type", "text/plain")
                    .body(body)?;
                info!("Built response: {:?}", response);
                Ok(response)
            }
            _ => Ok(Response::builder()
                .status(StatusCode::NOT_FOUND)
                .body(Full::new(Bytes::from("Not found")))
                .unwrap()),
        }
    }

    pub async fn run(metrics: Arc<Metrics>) -> Result<()> {
        let listener = TcpListener::bind(("0.0.0.0", 9464)).await?;
        info!("Metrics server listening on port 9464");
        loop {
            let (stream, _) = listener.accept().await?;
            let io = TokioIo::new(stream);

            let metrics_clone = Arc::clone(&metrics);
            tokio::task::spawn(async move {
                if let Err(err) = http1::Builder::new()
                    .serve_connection(io, service_fn(|req| metrics_clone.metrics_handler(req)))
                    .await
                {
                    error!("Error serving metrics: {}", err);
                }
            });
        }
    }
}