Add more unit test coverage

Fix links to external vendors OTLP docs

pr feedback: LazyLock meter, debug and todo removal, comments

Author: swcollard

Cargo.toml

@@ -54,6 +54,9 @@ url = { version = "2.4", features = ["serde"] }
 [workspace.metadata]
 crane.name = "apollo-mcp"
 
+# This allows usage of coverage(off) attribute without causing a linting error.
+# This attribute doesn't work in stable Rust yet and can be removed whenever it does.
+# See https://github.com/apollographql/apollo-mcp-server/pull/372
 [workspace.lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage_nightly)'] }
 

crates/apollo-mcp-server/build.rs

@@ -100,10 +100,6 @@ fn main() {
     // Generate the keys
     let telemetry_attribute_data = flatten(telemetry.attributes);
     let telemetry_metrics_data = flatten(telemetry.metrics);
-    println!(
-        "a {:?} | m {:?}",
-        telemetry_attribute_data, telemetry_metrics_data
-    );
 
     // Write out the generated keys
     let out_dir = std::env::var_os("OUT_DIR").expect("could not retrieve output directory");

crates/apollo-mcp-server/src/graphql.rs

@@ -1,7 +1,8 @@
 //! Execute GraphQL operations from an MCP tool
 
+use crate::errors::McpError;
 use crate::generated::telemetry::{TelemetryAttribute, TelemetryMetric};
-use crate::{errors::McpError, meter::get_meter};
+use crate::meter;
 use opentelemetry::KeyValue;
 use reqwest::header::{HeaderMap, HeaderValue};
 use reqwest_middleware::{ClientBuilder, Extension};
@@ -40,7 +41,7 @@ pub trait Executable {
     /// Execute as a GraphQL operation using the endpoint and headers
     #[tracing::instrument(skip(self, request))]
     async fn execute(&self, request: Request<'_>) -> Result<CallToolResult, McpError> {
-        let meter = get_meter();
+        let meter = &meter::METER;
         let start = std::time::Instant::now();
         let mut op_id: Option<String> = None;
         let client_metadata = serde_json::json!({
@@ -135,14 +136,13 @@ pub trait Executable {
             ),
             KeyValue::new(
                 TelemetryAttribute::OperationId.to_key(),
-                op_id.unwrap_or("unknown".to_string()),
+                op_id.unwrap_or("".to_string()),
             ),
             KeyValue::new(
                 TelemetryAttribute::OperationSource.to_key(),
-                if self.persisted_query_id().is_some() {
-                    "persisted_query"
-                } else {
-                    "operation"
+                match self.persisted_query_id() {
+                    Some(_) => "persisted_query",
+                    None => "operation",
                 },
             ),
         ];
@@ -162,6 +162,7 @@ pub trait Executable {
 #[cfg(test)]
 mod test {
     use crate::errors::McpError;
+    use crate::generated::telemetry::TelemetryMetric;
     use crate::graphql::{Executable, OperationDetails, Request};
     use http::{HeaderMap, HeaderValue};
     use opentelemetry::global;
@@ -453,7 +454,7 @@ mod test {
                 .find(|scope_metrics| scope_metrics.scope().name() == "apollo.mcp")
             {
                 for metric in scope_metrics.metrics() {
-                    if metric.name() == "apollo.mcp.operation.count"
+                    if metric.name() == TelemetryMetric::OperationCount.as_str()
                         && let AggregatedMetrics::U64(MetricData::Sum(data)) = metric.data()
                     {
                         for point in data.data_points() {

crates/apollo-mcp-server/src/lib.rs

@@ -17,6 +17,7 @@ pub(crate) mod schema_tree_shake;
 pub mod server;
 pub mod telemetry_attributes;
 
+/// These values are generated at build time by build.rs using telemetry.toml as input.
 pub mod generated {
     pub mod telemetry {
         include!(concat!(env!("OUT_DIR"), "/telemetry_attributes.rs"));

crates/apollo-mcp-server/src/meter.rs

@@ -1,8 +1,4 @@
 use opentelemetry::{global, metrics::Meter};
-use std::sync::OnceLock;
+use std::sync::LazyLock;
 
-static METER: OnceLock<Meter> = OnceLock::new();
-
-pub fn get_meter() -> &'static Meter {
-    METER.get_or_init(|| global::meter(env!("CARGO_PKG_NAME")))
-}
+pub static METER: LazyLock<Meter> = LazyLock::new(|| global::meter(env!("CARGO_PKG_NAME")));

crates/apollo-mcp-server/src/runtime/filtering_exporter.rs

@@ -28,12 +28,6 @@ where
         for span in &mut batch {
             span.attributes
                 .retain(|kv| filter_omitted_apollo_attributes(kv, &self.omitted));
-
-            // TODO: while not strictly necessary for dealing with high-cardinality, do we want to
-            //  filter out from span.events.events as well?
-            // for ev in &mut span.events.events {
-            //     ev.attributes.retain(|kv| filter_omitted_apollo_attributes(kv, &self.allow));
-            // }
         }
 
         self.inner.export(batch)

crates/apollo-mcp-server/src/runtime/telemetry.rs

@@ -345,6 +345,24 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn http_protocol_returns_valid_meter_provider() {
+        let config = test_config(
+            None,
+            None,
+            Some(MetricsExporters {
+                otlp: Some(OTLPMetricExporter {
+                    protocol: "http/protobuf".to_string(),
+                    endpoint: "http://localhost:4318/v1/metrics".to_string(),
+                }),
+                omitted_attributes: None,
+            }),
+            None,
+        );
+        let result = init_meter_provider(&config.telemetry);
+        assert!(result.is_ok());
+    }
+
     #[tokio::test]
     async fn unknown_protocol_raises_tracer_provider_error() {
         let config = test_config(
@@ -368,4 +386,23 @@ mod tests {
                 .unwrap_or(false)
         );
     }
+
+    #[tokio::test]
+    async fn http_protocol_returns_valid_tracer_provider() {
+        let config = test_config(
+            None,
+            None,
+            None,
+            Some(TracingExporters {
+                otlp: Some(OTLPTracingExporter {
+                    protocol: "http/protobuf".to_string(),
+                    endpoint: "http://localhost:4318/v1/traces".to_string(),
+                }),
+                sampler: Default::default(),
+                omitted_attributes: None,
+            }),
+        );
+        let result = init_tracer_provider(&config.telemetry);
+        assert!(result.is_ok());
+    }
 }

crates/apollo-mcp-server/src/server/states/running.rs

@@ -22,6 +22,7 @@ use tracing::{debug, error};
 use url::Url;
 
 use crate::generated::telemetry::{TelemetryAttribute, TelemetryMetric};
+use crate::meter;
 use crate::{
     auth::ValidToken,
     custom_scalar_map::CustomScalarMap,
@@ -35,7 +36,6 @@ use crate::{
         search::{SEARCH_TOOL_NAME, Search},
         validate::{VALIDATE_TOOL_NAME, Validate},
     },
-    meter::get_meter,
     operations::{MutationMode, Operation, RawOperation},
 };
 
@@ -182,7 +182,7 @@ impl ServerHandler for Running {
         _request: InitializeRequestParam,
         context: RequestContext<RoleServer>,
     ) -> Result<InitializeResult, McpError> {
-        let meter = get_meter();
+        let meter = &meter::METER;
         meter
             .u64_counter(TelemetryMetric::InitializeCount.as_str())
             .build()
@@ -199,7 +199,7 @@ impl ServerHandler for Running {
         request: CallToolRequestParam,
         context: RequestContext<RoleServer>,
     ) -> Result<CallToolResult, McpError> {
-        let meter = get_meter();
+        let meter = &meter::METER;
         let start = std::time::Instant::now();
         let tool_name = request.name.clone();
         let result = match tool_name.as_ref() {
@@ -321,7 +321,7 @@ impl ServerHandler for Running {
         _request: Option<PaginatedRequestParam>,
         _context: RequestContext<RoleServer>,
     ) -> Result<ListToolsResult, McpError> {
-        let meter = get_meter();
+        let meter = &meter::METER;
         meter
             .u64_counter(TelemetryMetric::ListToolsCount.as_str())
             .build()
@@ -344,7 +344,7 @@ impl ServerHandler for Running {
     }
 
     fn get_info(&self) -> ServerInfo {
-        let meter = get_meter();
+        let meter = &meter::METER;
         meter
             .u64_counter(TelemetryMetric::GetInfoCount.as_str())
             .build()

crates/apollo-mcp-server/src/server/states/starting.rs

@@ -367,7 +367,11 @@ mod tests {
                 disable_auth_token_passthrough: false,
                 search_leaf_depth: 5,
                 index_memory_bytes: 1024 * 1024 * 1024,
-                health_check: HealthCheckConfig::default(),
+                health_check: HealthCheckConfig {
+                    enabled: true,
+                    ..Default::default()
+                },
+                cors: Default::default(),
             },
             schema: Schema::parse_and_validate("type Query { hello: String }", "test.graphql")
                 .expect("Valid schema"),

docs/source/telemetry.mdx

@@ -66,8 +66,8 @@ telemetry:
 
 The MCP server works with any OTLP-compatible backend. Consult your provider's documentation for specific endpoint URLs and authentication:
 
-- [Datadog OTLP Integration](https://docs.datadoghq.com/tracing/setup_overview/open_standards/otlp_ingest_in_datadog/) - Native OTLP support
-- [New Relic OpenTelemetry](https://docs.newrelic.com/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/) - Direct OTLP ingestion
+- [Datadog OTLP Integration](https://docs.datadoghq.com/opentelemetry/setup/otlp_ingest_in_the_agent/) - Native OTLP support
+- [New Relic OpenTelemetry](https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-otlp/) - Direct OTLP ingestion
 - [AWS Observability](https://aws-otel.github.io/docs/introduction) - Via AWS Distro for OpenTelemetry
 - [Grafana Cloud](https://grafana.com/docs/grafana-cloud/send-data/otlp/) - Hosted Grafana with OTLP
 - [Honeycomb](https://docs.honeycomb.io/getting-data-in/opentelemetry/) - OpenTelemetry-native platform