feat: adding ability to omit attributes for traces and metrics (#358)

* feat: adding ability to omit attributes for traces and metrics

* chore: adding changeset

* chore: updating changeset text

* chore: removing unused file

* chore: renaming exporter file

* chore: renaming module

* re-running checks

* chore: auto-gen the as_str function using enums instead of constants

* chore: updating changeset entry and fixing fields in instruemnt attribute

* chore: adding description as a doc string

* chore: updating changeset  entry

* chore: updating operation attribute descriptions

* chore: updating operation_type attribute to operation_source

* chore: skipping request from instrumentation

* chore: fixing clippy issues

* re-running nix build

* updating unit test snapshot

* chore: fixing toml formatting issues

* test: removing asserts on constants

* chore: format issues

* test: adjusting unit test to not use local envar

* revert: undoing accidental commit

* test: removing unnecessary assert

Author: alocay

.changesets/feat_allow_attribute_configuration_alocay.md

@@ -0,0 +1,70 @@
+### feat: adding ability to omit attributes for traces and metrics - @alocay PR #358
+
+Adding ability to configure which attributes are omitted from telemetry traces and metrics.
+
+1. Using a Rust build script (`build.rs`) to auto-generate telemetry attribute code based on the data found in `telemetry.toml`.
+2. Utilizing an enum for attributes so typos in the config file raise an error.
+3. Omitting trace attributes by filtering it out in a custom exporter.
+4. Omitting metric attributes by indicating which attributes are allowed via a view.
+5. Created `telemetry_attributes.rs` to map `TelemetryAttribute` enum to a OTEL `Key`.
+
+The `telemetry.toml` file includes attributes (both for metrics and traces) as well as list of metrics gathered. An example would look like the following:
+```
+[attributes.apollo.mcp]
+my_attribute = "Some attribute info"
+
+[metrics.apollo.mcp]
+some.count = "Some metric count info"
+```
+This would generate a file that looks like the following:
+```
+/// All TelemetryAttribute values
+pub const ALL_ATTRS: &[TelemetryAttribute; 1usize] = &[
+    TelemetryAttribute::MyAttribute
+];
+#[derive(Debug, ::serde::Deserialize, ::schemars::JsonSchema,, Clone, Eq, PartialEq, Hash, Copy)]
+pub enum TelemetryAttribute {
+    ///Some attribute info
+    #[serde(alias = "my_attribute")]
+    MyAttribute,
+}
+impl TelemetryAttribute {
+    /// Supported telemetry attribute (tags) values
+    pub const fn as_str(&self) -> &'static str {
+        match self {
+            TelemetryAttribute::MyAttribute => "apollo.mcp.my_attribute",
+        }
+    }
+}
+#[derive(Debug, ::serde::Deserialize, ::schemars::JsonSchema,, Clone, Eq, PartialEq, Hash, Copy)]
+pub enum TelemetryMetric {
+    ///Some metric count info
+    #[serde(alias = "some.count")]
+    SomeCount,
+}
+impl TelemetryMetric {
+    /// Converts TelemetryMetric to &str
+    pub const fn as_str(&self) -> &'static str {
+        match self {
+            TelemetryMetric::SomeCount => "apollo.mcp.some.count",
+        }
+    }
+}
+```
+An example configuration that omits `tool_name` attribute for metrics and `request_id` for tracing would look like the following:
+```
+telemetry:
+  exporters:
+    metrics:
+      otlp:
+        endpoint: "http://localhost:4317"
+        protocol: "grpc"
+      omitted_attributes:
+        - tool_name
+    tracing:
+      otlp:
+        endpoint: "http://localhost:4317"
+        protocol: "grpc"
+      omitted_attributes:
+        - request_id
+```

Cargo.lock

@@ -6,6 +6,7 @@ license-file.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
+build = "build.rs"
 
 default-run = "apollo-mcp-server"
 
@@ -42,7 +43,9 @@ opentelemetry-otlp = { version = "0.30.0", features = [
 opentelemetry-resource-detectors = "0.9.0"
 opentelemetry-semantic-conventions = "0.30.0"
 opentelemetry-stdout = "0.30.0"
-opentelemetry_sdk = "0.30.0"
+opentelemetry_sdk = { version = "0.30.0", features = [
+  "spec_unstable_metrics_views",
+] }
 regex = "1.11.1"
 reqwest-middleware = "0.4.2"
 reqwest-tracing = { version = "0.5.8", features = ["opentelemetry_0_30"] }
@@ -66,6 +69,7 @@ tracing-opentelemetry = "0.31.0"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 tracing.workspace = true
 url.workspace = true
+async-trait = "0.1.89"
 
 [dev-dependencies]
 chrono = { version = "0.4.41", default-features = false, features = ["now"] }
@@ -77,6 +81,14 @@ rstest.workspace = true
 tokio.workspace = true
 tracing-test = "0.2.5"
 
+[build-dependencies]
+cruet = "0.15.0"
+prettyplease = "0.2.37"
+quote = "1.0.40"
+serde.workspace = true
+syn = "2.0.106"
+toml = "0.9.5"
+
 [lints]
 workspace = true
 

crates/apollo-mcp-server/Cargo.toml

@@ -0,0 +1,173 @@
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::expect_used)]
+#![allow(clippy::panic)]
+
+//! Build Script for the Apollo MCP Server
+//!
+//! This mostly compiles all the available telemetry attributes
+use quote::__private::TokenStream;
+use quote::quote;
+use serde::Deserialize;
+use std::io::Write;
+use std::{collections::VecDeque, io::Read as _};
+use syn::{Ident, parse2};
+
+#[derive(Deserialize)]
+struct TelemetryTomlData {
+    attributes: toml::Table,
+    metrics: toml::Table,
+}
+
+#[derive(Eq, PartialEq, Debug, Clone)]
+struct TelemetryData {
+    name: String,
+    alias: String,
+    value: String,
+    description: String,
+}
+
+fn flatten(table: toml::Table) -> Vec<TelemetryData> {
+    let mut to_visit = VecDeque::from_iter(table.into_iter().map(|(key, val)| (vec![key], val)));
+    let mut telemetry_data = Vec::new();
+
+    while let Some((key, value)) = to_visit.pop_front() {
+        match value {
+            toml::Value::String(val) => {
+                let last_key = key.last().unwrap().clone();
+                telemetry_data.push(TelemetryData {
+                    name: cruet::to_pascal_case(last_key.as_str()),
+                    alias: last_key,
+                    value: key.join("."),
+                    description: val,
+                });
+            }
+            toml::Value::Table(map) => to_visit.extend(
+                map.into_iter()
+                    .map(|(nested_key, value)| ([key.clone(), vec![nested_key]].concat(), value)),
+            ),
+
+            _ => panic!("telemetry values should be string descriptions"),
+        };
+    }
+
+    telemetry_data
+}
+
+fn generate_enum(telemetry_data: &[TelemetryData]) -> Vec<TokenStream> {
+    telemetry_data
+        .iter()
+        .map(|t| {
+            let enum_value_ident = quote::format_ident!("{}", &t.name);
+            let alias = &t.alias;
+            let doc_message = &t.description;
+            quote! {
+                #[doc = #doc_message]
+                #[serde(alias = #alias)]
+                #enum_value_ident
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
+fn generate_enum_as_str_matches(
+    telemetry_data: &[TelemetryData],
+    enum_ident: Ident,
+) -> Vec<TokenStream> {
+    telemetry_data
+        .iter()
+        .map(|t| {
+            let name_ident = quote::format_ident!("{}", &t.name);
+            let value = &t.value;
+            quote! {
+                #enum_ident::#name_ident => #value
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
+fn main() {
+    // Parse the telemetry file
+    let telemetry: TelemetryTomlData = {
+        let mut raw = String::new();
+        std::fs::File::open("telemetry.toml")
+            .expect("could not open telemetry file")
+            .read_to_string(&mut raw)
+            .expect("could not read telemetry file");
+
+        toml::from_str(&raw).expect("could not parse telemetry file")
+    };
+
+    // 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");
+    let dest_path = std::path::Path::new(&out_dir).join("telemetry_attributes.rs");
+    let mut generated_file =
+        std::fs::File::create(&dest_path).expect("could not create generated code file");
+
+    let attribute_keys_len = telemetry_attribute_data.len();
+    let attribute_enum_keys = generate_enum(&telemetry_attribute_data);
+    let all_attribute_enum_values = &telemetry_attribute_data
+        .iter()
+        .map(|t| quote::format_ident!("{}", t.name));
+    let all_attribute_enum_values = (*all_attribute_enum_values).clone();
+    let attribute_enum_name = quote::format_ident!("{}", "TelemetryAttribute");
+    let attribute_enum_as_str_matches =
+        generate_enum_as_str_matches(&telemetry_attribute_data, attribute_enum_name.clone());
+
+    let metric_enum_name = quote::format_ident!("{}", "TelemetryMetric");
+    let metric_enum_keys = generate_enum(&telemetry_metrics_data);
+    let metric_enum_as_str_matches =
+        generate_enum_as_str_matches(&telemetry_metrics_data, metric_enum_name.clone());
+
+    let tokens = quote! {
+        /// All TelemetryAttribute values
+        pub const ALL_ATTRS: &[TelemetryAttribute; #attribute_keys_len] = &[#(TelemetryAttribute::#all_attribute_enum_values),*];
+
+        /// Supported telemetry attribute (tags) values
+        #[derive(Debug, ::serde::Deserialize, ::schemars::JsonSchema, Clone, Eq, PartialEq, Hash, Copy)]
+        pub enum #attribute_enum_name {
+            #(#attribute_enum_keys),*
+        }
+
+        impl #attribute_enum_name {
+            /// Converts TelemetryAttribute to &str
+            pub const fn as_str(&self) -> &'static str {
+                match self {
+                   #(#attribute_enum_as_str_matches),*
+                }
+            }
+        }
+
+        /// Supported telemetry metrics
+        #[derive(Debug, ::serde::Deserialize, ::schemars::JsonSchema, Clone, Eq, PartialEq, Hash, Copy)]
+        pub enum #metric_enum_name {
+            #(#metric_enum_keys),*
+        }
+
+        impl #metric_enum_name {
+            /// Converts TelemetryMetric to &str
+            pub const fn as_str(&self) -> &'static str {
+                match self {
+                   #(#metric_enum_as_str_matches),*
+                }
+            }
+        }
+    };
+
+    let file = parse2(tokens).expect("Could not parse TokenStream");
+    let code = prettyplease::unparse(&file);
+
+    write!(generated_file, "{}", code).expect("Failed to write generated code");
+
+    // Inform cargo that we only want this to run when either this file or the telemetry
+    // one changes.
+    println!("cargo::rerun-if-changed=build.rs");
+    println!("cargo::rerun-if-changed=telemetry.toml");
+}