fix(analytics): fixed response code to 501

crates/analytics/src/api_event/core.rs

@@ -8,6 +8,7 @@ use api_models::analytics::{
     AnalyticsMetadata, ApiEventFiltersResponse, GetApiEventFiltersRequest,
     GetApiEventMetricRequest, MetricsResponse,
 };
+use common_utils::errors::ReportSwitchExt;
 use error_stack::{IntoReport, ResultExt};
 use router_env::{
     instrument, logger,
@@ -32,16 +33,18 @@ pub async fn api_events_core(
     merchant_id: String,
 ) -> AnalyticsResult<Vec<ApiLogsResult>> {
     let data = match pool {
-        AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented)
-            .into_report()
-            .attach_printable("SQL Analytics is not implemented for API Events"),
+        AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented(
+            "API Events not implemented for SQLX",
+        ))
+        .into_report()
+        .attach_printable("SQL Analytics is not implemented for API Events"),
         AnalyticsProvider::Clickhouse(pool) => get_api_event(&merchant_id, req, pool).await,
         AnalyticsProvider::CombinedSqlx(_sqlx_pool, ckh_pool)
         | AnalyticsProvider::CombinedCkh(_sqlx_pool, ckh_pool) => {
             get_api_event(&merchant_id, req, ckh_pool).await
         }
     }
-    .change_context(AnalyticsError::UnknownError)?;
+    .switch()?;
     Ok(data)
 }
 
@@ -58,17 +61,19 @@ pub async fn get_filters(
     let mut res = ApiEventFiltersResponse::default();
     for dim in req.group_by_names {
         let values = match pool {
-            AnalyticsProvider::Sqlx(_pool) => Err(FiltersError::NotImplemented)
-                .into_report()
-                .attach_printable("SQL Analytics is not implemented for API Events"),
+            AnalyticsProvider::Sqlx(_pool) => Err(FiltersError::NotImplemented(
+                "API Events not implemented for SQLX",
+            ))
+            .into_report()
+            .attach_printable("SQL Analytics is not implemented for API Events"),
             AnalyticsProvider::Clickhouse(ckh_pool)
             | AnalyticsProvider::CombinedSqlx(_, ckh_pool)
             | AnalyticsProvider::CombinedCkh(_, ckh_pool) => {
                 get_api_event_filter_for_dimension(dim, &merchant_id, &req.time_range, ckh_pool)
                     .await
             }
         }
-        .change_context(AnalyticsError::UnknownError)?
+        .switch()?
         .into_iter()
         .filter_map(|fil: ApiEventFilter| match dim {
             ApiEventDimensions::StatusCode => fil.status_code.map(|i| i.to_string()),

crates/analytics/src/sdk_events/core.rs

@@ -7,6 +7,7 @@ use api_models::analytics::{
     AnalyticsMetadata, GetSdkEventFiltersRequest, GetSdkEventMetricRequest, MetricsResponse,
     SdkEventFiltersResponse,
 };
+use common_utils::errors::ReportSwitchExt;
 use error_stack::{IntoReport, ResultExt};
 use router_env::{instrument, logger, tracing};
 
@@ -28,16 +29,18 @@ pub async fn sdk_events_core(
     publishable_key: String,
 ) -> AnalyticsResult<Vec<SdkEventsResult>> {
     match pool {
-        AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented)
-            .into_report()
-            .attach_printable("SQL Analytics is not implemented for Sdk Events"),
+        AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented(
+            "SDK Events not implemented for SQLX",
+        ))
+        .into_report()
+        .attach_printable("SQL Analytics is not implemented for Sdk Events"),
         AnalyticsProvider::Clickhouse(pool) => get_sdk_event(&publishable_key, req, pool).await,
         AnalyticsProvider::CombinedSqlx(_sqlx_pool, ckh_pool)
         | AnalyticsProvider::CombinedCkh(_sqlx_pool, ckh_pool) => {
             get_sdk_event(&publishable_key, req, ckh_pool).await
         }
     }
-    .change_context(AnalyticsError::UnknownError)
+    .switch()
 }
 
 #[instrument(skip_all)]
@@ -159,9 +162,11 @@ pub async fn get_filters(
     if let Some(publishable_key) = publishable_key {
         for dim in req.group_by_names {
             let values = match pool {
-                AnalyticsProvider::Sqlx(_pool) => Err(FiltersError::NotImplemented)
-                    .into_report()
-                    .attach_printable("SQL Analytics is not implemented for SDK Events"),
+                AnalyticsProvider::Sqlx(_pool) => Err(FiltersError::NotImplemented(
+                    "SDK Events not implemented for SQLX",
+                ))
+                .into_report()
+                .attach_printable("SQL Analytics is not implemented for SDK Events"),
                 AnalyticsProvider::Clickhouse(pool) => {
                     get_sdk_event_filter_for_dimension(dim, publishable_key, &req.time_range, pool)
                         .await

crates/analytics/src/types.rs

@@ -8,6 +8,7 @@ use common_utils::{
 use error_stack::{report, Report, ResultExt};
 
 use super::query::QueryBuildingError;
+use crate::errors::AnalyticsError;
 
 #[derive(serde::Deserialize, Debug, serde::Serialize)]
 #[serde(rename_all = "snake_case")]
@@ -124,8 +125,8 @@ pub enum FiltersError {
     #[error("Error running Query")]
     QueryExecutionFailure,
     #[allow(dead_code)]
-    #[error("Not Implemented")]
-    NotImplemented,
+    #[error("Not Implemented: {0}")]
+    NotImplemented(&'static str),
 }
 
 impl ErrorSwitch<FiltersError> for QueryBuildingError {
@@ -134,4 +135,13 @@ impl ErrorSwitch<FiltersError> for QueryBuildingError {
     }
 }
 
+impl ErrorSwitch<AnalyticsError> for FiltersError {
+    fn switch(&self) -> AnalyticsError {
+        match self {
+            Self::QueryBuildingError | Self::QueryExecutionFailure => AnalyticsError::UnknownError,
+            Self::NotImplemented(a) => AnalyticsError::NotImplemented(a),
+        }
+    }
+}
+
 impl_misc_api_event_type!(AnalyticsDomain);

crates/router/src/core/webhooks.rs

@@ -909,7 +909,7 @@ pub async fn webhooks_wrapper<W: types::OutgoingWebhookType, Ctx: PaymentMethodR
         None,
         api_event,
         req,
-        Some(req.method().to_string()),
+        req.method(),
     );
     match api_event.clone().try_into() {
         Ok(event) => {

crates/router/src/events/api_logs.rs

@@ -41,7 +41,7 @@ pub struct ApiEvent {
     #[serde(flatten)]
     event_type: ApiEventsType,
     hs_latency: Option<u128>,
-    http_method: Option<String>,
+    http_method: String,
 }
 
 impl ApiEvent {
@@ -59,7 +59,7 @@ impl ApiEvent {
         error: Option<serde_json::Value>,
         event_type: ApiEventsType,
         http_req: &HttpRequest,
-        http_method: Option<String>,
+        http_method: &http::Method,
     ) -> Self {
         Self {
             merchant_id,
@@ -83,7 +83,7 @@ impl ApiEvent {
             url_path: http_req.path().to_string(),
             event_type,
             hs_latency,
-            http_method,
+            http_method: http_method.to_string(),
         }
     }
 }

crates/router/src/services/api.rs

@@ -938,7 +938,7 @@ where
         error,
         event_type.unwrap_or(ApiEventsType::Miscellaneous),
         request,
-        Some(request.method().to_string()),
+        request.method(),
     );
     match api_event.clone().try_into() {
         Ok(event) => {