fix: improve error messages /last-approved

Author: samparsky

primitives/src/big_num.rs

@@ -10,7 +10,19 @@ use num_derive::{Num, NumOps, One, Zero};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(
-    Serialize, Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, NumOps, One, Zero, Num, Default
+    Serialize,
+    Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    NumOps,
+    One,
+    Zero,
+    Num,
+    Default,
 )]
 pub struct BigNum(
     #[serde(

sentry/src/analytics_recorder.rs

@@ -3,8 +3,8 @@ use crate::Session;
 use primitives::sentry::Event;
 use primitives::sentry::{ChannelReport, PublisherReport};
 use primitives::{BigNum, Channel};
-use redis::pipe;
 use redis::aio::MultiplexedConnection;
+use redis::pipe;
 use slog::{error, Logger};
 
 pub fn get_payout(channel: &Channel, event: &Event) -> BigNum {
@@ -16,7 +16,7 @@ pub fn get_payout(channel: &Channel, event: &Event) -> BigNum {
                     return click.min;
                 }
             }
-            
+
             Default::default()
         }
         _ => Default::default(),
@@ -56,23 +56,13 @@ pub async fn record(
 
                 if let Some(ad_unit) = ad_unit {
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            PublisherReport::AdUnit,
-                            event,
-                            publisher
-                        ),
+                        format!("{}:{}:{}", PublisherReport::AdUnit, event, publisher),
                         ad_unit,
                         1,
                     )
                     .ignore();
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            ChannelReport::AdUnit,
-                            event,
-                            publisher
-                        ),
+                        format!("{}:{}:{}", ChannelReport::AdUnit, event, publisher),
                         ad_unit,
                         1,
                     )
@@ -81,23 +71,13 @@ pub async fn record(
 
                 if let Some(ad_slot) = ad_slot {
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            PublisherReport::AdSlot,
-                            event,
-                            publisher
-                        ),
+                        format!("{}:{}:{}", PublisherReport::AdSlot, event, publisher),
                         ad_slot,
                         1,
                     )
                     .ignore();
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            PublisherReport::AdSlotPay,
-                            event,
-                            publisher
-                        ),
+                        format!("{}:{}:{}", PublisherReport::AdSlotPay, event, publisher),
                         ad_slot,
                         pay_amount,
                     )
@@ -120,40 +100,25 @@ pub async fn record(
                 }
 
                 let hostname = (referrer.as_ref())
-                                .or_else(|| session.referrer_header.as_ref())
-                                .map(|rf| rf.split('/').nth(2).map(ToString::to_string))
-                                .flatten();
+                    .or_else(|| session.referrer_header.as_ref())
+                    .map(|rf| rf.split('/').nth(2).map(ToString::to_string))
+                    .flatten();
 
                 if let Some(hostname) = &hostname {
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            PublisherReport::Hostname,
-                            event,
-                            publisher
-                        ),
+                        format!("{}:{}:{}", PublisherReport::Hostname, event, publisher),
                         hostname,
                         1,
                     )
                     .ignore();
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            ChannelReport::Hostname,
-                            event,
-                            channel.id
-                        ),
+                        format!("{}:{}:{}", ChannelReport::Hostname, event, channel.id),
                         hostname,
                         1,
                     )
                     .ignore();
                     db.zincr(
-                        format!(
-                            "{}:{}:{}",
-                            ChannelReport::HostnamePay,
-                            event,
-                            channel.id
-                        ),
+                        format!("{}:{}:{}", ChannelReport::HostnamePay, event, channel.id),
                         hostname,
                         1,
                     )

sentry/src/db/analytics.rs

@@ -2,13 +2,13 @@ use crate::db::DbPool;
 use crate::epoch;
 use crate::Session;
 use bb8::RunError;
+use bb8_postgres::tokio_postgres::types::ToSql;
 use chrono::Utc;
 use primitives::analytics::{AnalyticsData, AnalyticsQuery, ANALYTICS_QUERY_LIMIT};
 use primitives::sentry::{AdvancedAnalyticsResponse, ChannelReport, PublisherReport};
-use bb8_postgres::tokio_postgres::types::{ToSql};
 use primitives::{ChannelId, ValidatorId};
-use redis::cmd;
 use redis::aio::MultiplexedConnection;
+use redis::cmd;
 use std::collections::HashMap;
 use std::error::Error;
 
@@ -69,7 +69,7 @@ pub async fn get_analytics(
 
     where_clauses.extend(vec![
         format!("event_type = ${}", params.len()),
-        format!("{} IS NOT NULL", metric)
+        format!("{} IS NOT NULL", metric),
     ]);
 
     if let Some(id) = channel_id {
@@ -80,12 +80,10 @@ pub async fn get_analytics(
     let mut select_clause = match analytics_type {
         AnalyticsType::Advertiser { session } => {
             if channel_id.is_none() {
-                where_clauses.push(
-                    format!(
-                        "channel_id IN (SELECT id FROM channels WHERE creator = '{}')",
-                        session.uid
-                    )
-                );
+                where_clauses.push(format!(
+                    "channel_id IN (SELECT id FROM channels WHERE creator = '{}')",
+                    session.uid
+                ));
             }
 
             format!(

sentry/src/routes/analytics.rs

@@ -87,10 +87,8 @@ pub async fn process_analytics<A: Adapter>(
 
     let channel_id = req.extensions().get::<ChannelId>();
 
-    let segment_channel = query
-        .segment_by_channel
-        .is_some();
-        
+    let segment_channel = query.segment_by_channel.is_some();
+
     let limit = query.limit;
 
     let aggr = get_analytics(

sentry/src/routes/channel.rs

@@ -116,12 +116,15 @@ pub async fn last_approved<A: Adapter>(
 
     let approve_state = match lastest_approve_state(&app.pool, &channel).await? {
         Some(approve_state) => approve_state,
-        None => return Ok(default_response)
+        None => return Ok(default_response),
     };
 
     let state_root = match approve_state.msg.clone() {
         MessageTypes::ApproveState(approve_state) => approve_state.state_root,
-        _ => return Err(ResponseError::BadRequest("invalid request".to_string())),
+        _ => {
+            error!(&app.logger, "{}", "failed to retrieve approved"; "module" => "last_approved");
+            return Err(ResponseError::BadRequest("an error occured".to_string()));
+        }
     };
 
     let new_state = latest_new_state(&app.pool, &channel, &state_root).await?;