refactor(ads-client): use any for simpler telemetry type

Author: Almaju

components/ads-client/src/client.rs

@@ -13,7 +13,7 @@ use crate::client::ad_response::{
 use crate::client::config::AdsClientConfig;
 use crate::client::telemetry::ClientOperationEvent;
 use crate::error::{RecordClickError, RecordImpressionError, ReportAdError, RequestAdsError};
-use crate::http_cache::{CacheOutcome, HttpCache, HttpCacheBuilderError, RequestCachePolicy};
+use crate::http_cache::{HttpCache, RequestCachePolicy};
 use crate::mars::MARSClient;
 use crate::telemetry::Telemetry;
 use ad_request::{AdPlacementRequest, AdRequest};
@@ -33,14 +33,7 @@ const DEFAULT_MAX_CACHE_SIZE_MIB: u64 = 10;
 
 pub struct AdsClient<T>
 where
-    T: Telemetry<CacheOutcome>
-        + Telemetry<ClientOperationEvent>
-        + Telemetry<HttpCacheBuilderError>
-        + Telemetry<RecordClickError>
-        + Telemetry<RecordImpressionError>
-        + Telemetry<ReportAdError>
-        + Telemetry<RequestAdsError>
-        + Telemetry<serde_json::Error>,
+    T: Telemetry,
 {
     client: MARSClient<T>,
     context_id_component: ContextIDComponent,
@@ -49,14 +42,7 @@ where
 
 impl<T> AdsClient<T>
 where
-    T: Telemetry<CacheOutcome>
-        + Telemetry<serde_json::Error>
-        + Telemetry<ClientOperationEvent>
-        + Telemetry<HttpCacheBuilderError>
-        + Telemetry<RecordClickError>
-        + Telemetry<RecordImpressionError>
-        + Telemetry<ReportAdError>
-        + Telemetry<RequestAdsError>,
+    T: Telemetry,
 {
     pub fn new(client_config: AdsClientConfig<T>) -> Self {
         let context_id = Uuid::new_v4().to_string();

components/ads-client/src/client/ad_response.rs

@@ -16,7 +16,7 @@ pub struct AdResponse<A: AdResponseValue> {
 }
 
 impl<A: AdResponseValue> AdResponse<A> {
-    pub fn parse<T: Telemetry<serde_json::Error> + ?Sized>(
+    pub fn parse<T: Telemetry>(
         data: serde_json::Value,
         telemetry: &T,
     ) -> Result<AdResponse<A>, serde_json::Error> {

components/ads-client/src/client/config.rs

@@ -8,9 +8,6 @@ use std::sync::Arc;
 use once_cell::sync::Lazy;
 use url::Url;
 
-use crate::client::telemetry::ClientOperationEvent;
-use crate::error::{RecordClickError, RecordImpressionError, ReportAdError, RequestAdsError};
-use crate::http_cache::{CacheOutcome, HttpCacheBuilderError};
 use crate::telemetry::Telemetry;
 
 static MARS_API_ENDPOINT_PROD: Lazy<Url> =
@@ -22,14 +19,7 @@ static MARS_API_ENDPOINT_STAGING: Lazy<Url> =
 
 pub struct AdsClientConfig<T>
 where
-    T: Telemetry<CacheOutcome>
-        + Telemetry<ClientOperationEvent>
-        + Telemetry<HttpCacheBuilderError>
-        + Telemetry<RecordClickError>
-        + Telemetry<RecordImpressionError>
-        + Telemetry<ReportAdError>
-        + Telemetry<RequestAdsError>
-        + Telemetry<serde_json::Error>,
+    T: Telemetry,
 {
     pub environment: Environment,
     pub cache_config: Option<AdsCacheConfig>,

components/ads-client/src/ffi/telemetry.rs

@@ -3,6 +3,7 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
+use std::any::Any;
 use std::sync::Arc;
 
 use crate::client::telemetry::ClientOperationEvent;
@@ -33,83 +34,67 @@ pub struct MozAdsTelemetryWrapper {
     pub inner: Arc<dyn MozAdsTelemetry>,
 }
 
-impl Telemetry<CacheOutcome> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &CacheOutcome) {
-        let label = match event {
-            CacheOutcome::Hit => "hit",
-            CacheOutcome::LookupFailed(_) => "lookup_failed",
-            CacheOutcome::NoCache => "no_cache",
-            CacheOutcome::MissNotCacheable => "miss_not_cacheable",
-            CacheOutcome::MissStored => "miss_stored",
-            CacheOutcome::StoreFailed(_) => "store_failed",
-            CacheOutcome::CleanupFailed(_) => "cleanup_failed",
-        };
-        self.inner.record_http_cache_outcome(label);
-    }
-}
-
-impl Telemetry<serde_json::Error> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &serde_json::Error) {
-        let label = "invalid_ad_item";
-        let value = format!("{}", event);
-        self.inner.record_deserialization_error(label, &value);
-    }
-}
-
-impl Telemetry<HttpCacheBuilderError> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &HttpCacheBuilderError) {
-        let label = match event {
-            HttpCacheBuilderError::EmptyDbPath => "empty_db_path",
-            HttpCacheBuilderError::Database(_) => "database_error",
-            HttpCacheBuilderError::InvalidMaxSize { .. } => "invalid_max_size",
-            HttpCacheBuilderError::InvalidTtl { .. } => "invalid_ttl",
-        };
-        let value = format!("{}", event);
-        self.inner.record_build_cache_error(label, &value);
-    }
-}
-
-impl Telemetry<RequestAdsError> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &RequestAdsError) {
-        let label = "request_ads";
-        let value = format!("{}", event);
-        self.inner.record_client_error(label, &value);
-    }
-}
-
-impl Telemetry<RecordClickError> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &RecordClickError) {
-        let label = "record_click";
-        let value = format!("{}", event);
-        self.inner.record_client_error(label, &value);
-    }
-}
-
-impl Telemetry<RecordImpressionError> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &RecordImpressionError) {
-        let label = "record_impression";
-        let value = format!("{}", event);
-        self.inner.record_client_error(label, &value);
-    }
-}
-
-impl Telemetry<ReportAdError> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &ReportAdError) {
-        let label = "report_ad";
-        let value = format!("{}", event);
-        self.inner.record_client_error(label, &value);
-    }
-}
-
-impl Telemetry<ClientOperationEvent> for MozAdsTelemetryWrapper {
-    fn record(&self, event: &ClientOperationEvent) {
-        let label = match event {
-            ClientOperationEvent::New => "new",
-            ClientOperationEvent::RecordClick => "record_click",
-            ClientOperationEvent::RecordImpression => "record_impression",
-            ClientOperationEvent::ReportAd => "report_ad",
-            ClientOperationEvent::RequestAds => "request_ads",
-        };
-        self.inner.record_client_operation_total(label);
+impl Telemetry for MozAdsTelemetryWrapper {
+    fn record(&self, event: &dyn Any) {
+        if let Some(cache_outcome) = event.downcast_ref::<CacheOutcome>() {
+            self.inner.record_http_cache_outcome(match cache_outcome {
+                CacheOutcome::Hit => "hit",
+                CacheOutcome::LookupFailed(_) => "lookup_failed",
+                CacheOutcome::NoCache => "no_cache",
+                CacheOutcome::MissNotCacheable => "miss_not_cacheable",
+                CacheOutcome::MissStored => "miss_stored",
+                CacheOutcome::StoreFailed(_) => "store_failed",
+                CacheOutcome::CleanupFailed(_) => "cleanup_failed",
+            });
+            return;
+        }
+        if let Some(client_op) = event.downcast_ref::<ClientOperationEvent>() {
+            self.inner.record_client_operation_total(match client_op {
+                ClientOperationEvent::New => "new",
+                ClientOperationEvent::RecordClick => "record_click",
+                ClientOperationEvent::RecordImpression => "record_impression",
+                ClientOperationEvent::ReportAd => "report_ad",
+                ClientOperationEvent::RequestAds => "request_ads",
+            });
+            return;
+        }
+        if let Some(cache_builder_error) = event.downcast_ref::<HttpCacheBuilderError>() {
+            self.inner.record_build_cache_error(
+                match cache_builder_error {
+                    HttpCacheBuilderError::EmptyDbPath => "empty_db_path",
+                    HttpCacheBuilderError::Database(_) => "database_error",
+                    HttpCacheBuilderError::InvalidMaxSize { .. } => "invalid_max_size",
+                    HttpCacheBuilderError::InvalidTtl { .. } => "invalid_ttl",
+                },
+                &format!("{}", cache_builder_error),
+            );
+            return;
+        }
+        if let Some(record_click_error) = event.downcast_ref::<RecordClickError>() {
+            self.inner
+                .record_client_error("record_click", &format!("{}", record_click_error));
+            return;
+        }
+        if let Some(record_impression_error) = event.downcast_ref::<RecordImpressionError>() {
+            self.inner
+                .record_client_error("record_impression", &format!("{}", record_impression_error));
+            return;
+        }
+        if let Some(report_ad_error) = event.downcast_ref::<ReportAdError>() {
+            self.inner
+                .record_client_error("report_ad", &format!("{}", report_ad_error));
+            return;
+        }
+        if let Some(request_ads_error) = event.downcast_ref::<RequestAdsError>() {
+            self.inner
+                .record_client_error("request_ads", &format!("{}", request_ads_error));
+            return;
+        }
+        if let Some(json_error) = event.downcast_ref::<serde_json::Error>() {
+            self.inner
+                .record_deserialization_error("invalid_ad_item", &format!("{}", json_error));
+            return;
+        }
+        eprintln!("Unsupported telemetry event type: {:?}", event.type_id());
     }
 }

components/ads-client/src/mars.rs

@@ -15,7 +15,7 @@ use crate::{
         check_http_status_for_error, CallbackRequestError, FetchAdsError, RecordClickError,
         RecordImpressionError, ReportAdError,
     },
-    http_cache::{CacheOutcome, HttpCache, HttpCacheError, RequestHash},
+    http_cache::{HttpCache, HttpCacheError, RequestHash},
     telemetry::Telemetry,
     RequestCachePolicy,
 };
@@ -24,7 +24,7 @@ use viaduct::Request;
 
 pub struct MARSClient<T>
 where
-    T: Telemetry<CacheOutcome> + Telemetry<serde_json::Error>,
+    T: Telemetry,
 {
     endpoint: Url,
     http_cache: Option<HttpCache>,
@@ -33,7 +33,7 @@ where
 
 impl<T> MARSClient<T>
 where
-    T: Telemetry<CacheOutcome> + Telemetry<serde_json::Error>,
+    T: Telemetry,
 {
     pub fn new(environment: Environment, http_cache: Option<HttpCache>, telemetry: Arc<T>) -> Self {
         let endpoint = environment.into_mars_url().clone();

components/ads-client/src/telemetry.rs

@@ -3,6 +3,8 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
-pub trait Telemetry<A>: Send + Sync {
-    fn record(&self, event: &A);
+use std::any::Any;
+
+pub trait Telemetry {
+    fn record(&self, event: &dyn Any);
 }

components/ads-client/src/test_utils.rs

@@ -3,7 +3,7 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
-use std::{collections::HashMap, fmt::Debug};
+use std::collections::HashMap;
 
 use url::Url;
 
@@ -21,8 +21,8 @@ pub const TEST_CONTEXT_ID: &str = "00000000-0000-4000-8000-000000000001";
 
 pub struct PrintAdsTelemetry;
 
-impl<A: Debug> Telemetry<A> for PrintAdsTelemetry {
-    fn record(&self, event: &A) {
+impl Telemetry for PrintAdsTelemetry {
+    fn record(&self, event: &dyn std::any::Any) {
         println!("record: {:?}", event);
     }
 }