text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
pub fn search_index_to_opensearch_index(&self, index: SearchIndex) -> String {
{
SearchIndex::PaymentAttempts => self.indexes.payment_attempts.clone(),<|fim_suffix|>
<|fim_middle|>
SearchIndex::SessionizerDisputes => self.indexes.sessionizer_disputes.clone(),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
pub fn get_amount_field(&self, index: SearchIndex) -> &str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
pub fn get_status_field(&self, index: SearchIndex) -> &str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use aws_config::{self, meta::region::RegionProviderChain, Region};
use serde_json::{json, Map, Value};
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
pub fn add_filter_clause(&mut self, lhs: String, rhs: Vec<Value>) -> QueryResult<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use aws_config::{self, meta::region::RegionProviderChain, Region};
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
pub fn set_time_range(&mut self, time_range: OpensearchTimeRange) -> QueryResult<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use aws_config::{self, meta::region::RegionProviderChain, Region};
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
pub fn set_offset_n_count(&mut self, offset: i64, count: i64) -> QueryResult<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use std::collections::HashSet;
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
use crate::{enums::AuthInfo, query::QueryBuildingError};
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use aws_config::{self, meta::region::RegionProviderChain, Region};
use storage_impl::errors::{ApplicationError, StorageError, StorageResult};
pub async fn get_opensearch_client(&self) -> StorageResult<Option<OpenSearchClient>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
pub fn search_index_to_opensearch_index(&self, index: SearchIndex) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use aws_config::{self, meta::region::RegionProviderChain, Region};
use crate::{enums::AuthInfo, query::QueryBuildingError};
fn switch(&self) -> OpenSearchError {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/opensearch.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ErrorSwitch},
types::TimeRange,
};
fn from(time_range: TimeRange) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/errors.rs | crate: analytics
use api_models::errors::types::{ApiError, ApiErrorResponse};
fn switch(&self) -> ApiErrorResponse {
{
Self::NotImplemented(feature) => ApiErrorResponse::NotImplemented(ApiError::new(
"IR",
0,
format!("{feature} is not implemented."),
None,
)),<|fim_suffix|>
<|fim_middle|>
Self::ForexFetchFailed => ApiErrorResponse::InternalServerError(ApiError::new(
"HE",
0,
"Failed to fetch currency exchange rate",
None,
)),
}
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/errors.rs | crate: analytics
use api_models::errors::types::{ApiError, ApiErrorResponse};
fn switch(&self) -> ApiErrorResponse {
match self {
Self::NotImplemented(feature) => ApiErrorResponse::NotImplemented(ApiError::new(
"IR",
0,
format!("{feature} is not implemented."),
None,
)),
Self::UnknownError => ApiErrorResponse::InternalServerError(ApiError::new(
"HE",
0,
"Something went wrong",
None,
)),
Self::AccessForbiddenError => {
ApiErrorResponse::Unauthorized(ApiError::new("IR", 0, "Access Forbidden", None))
}
Self::ForexFetchFailed => ApiErrorResponse::InternalServerError(ApiError::new(
"HE",
0,
"Failed to fetch currency exchange rate",
None,
)),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/outgoing_webhook_event/core.rs | crate: analytics
use api_models::analytics::outgoing_webhook_event::OutgoingWebhookLogsRequest;
use common_utils::errors::ReportSwitchExt;
use super::events::{get_outgoing_webhook_event, OutgoingWebhookLogsResult};
use crate::{errors::AnalyticsResult, types::FiltersError, AnalyticsProvider};
pub async fn outgoing_webhook_events_core(
pool: &AnalyticsProvider,
req: OutgoingWebhookLogsRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<Vec<OutgoingWebhookLogsResult>> {
{
AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented(
"Outgoing Webhook Events Logs not implemented for SQLX",
))
.attach_printable("SQL Analytics is not implemented for Outgoing Webhook Events"),<|fim_suffix|>
<|fim_middle|>
AnalyticsProvider::Clickhouse(ckh_pool)
| AnalyticsProvider::CombinedSqlx(_, ckh_pool)
| AnalyticsProvider::CombinedCkh(_, ckh_pool) => {
get_outgoing_webhook_event(merchant_id, req, ckh_pool).await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/outgoing_webhook_event/core.rs | crate: analytics
use api_models::analytics::outgoing_webhook_event::OutgoingWebhookLogsRequest;
use common_utils::errors::ReportSwitchExt;
use super::events::{get_outgoing_webhook_event, OutgoingWebhookLogsResult};
use crate::{errors::AnalyticsResult, types::FiltersError, AnalyticsProvider};
pub async fn outgoing_webhook_events_core(
pool: &AnalyticsProvider,
req: OutgoingWebhookLogsRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<Vec<OutgoingWebhookLogsResult>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/core.rs | crate: analytics
total_payment_processed_count: Some(total_payment_processed_count),
total_payment_processed_count_without_smart_retries: Some(
total_payment_processed_count_without_smart_retries,
),
total_failure_reasons_count: Some(total_failure_reasons_count),
total_failure_reasons_count_without_smart_retries: Some(
total_failure_reasons_count_without_smart_retries,
),
}],
})
}
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetPaymentFiltersRequest,
auth: &AuthInfo,
) -> AnalyticsResult<PaymentFiltersResponse> {
let mut res = PaymentFiltersResponse::default();
for dim in req.group_by_names {
let values = match pool {
AnalyticsProvider::Sqlx(pool) => {
get_payment_filter_for_dimension(dim, auth, &req.time_range, pool)
.await
}
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetPaymentFiltersRequest,
auth: &AuthInfo,
) -> AnalyticsResult<PaymentFiltersResponse> {
{
(Ok(ref sqlx_res), Ok(ref ckh_res)) if sqlx_res != ckh_res => {
router_env::logger::error!(clickhouse_result=?ckh_res, postgres_result=?sqlx_res, "Mismatch between clickhouse & postgres payments analytics filters")
},<|fim_suffix|>
<|fim_middle|>
_ => {}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/core.rs | crate: analytics
use api_models::analytics::{
payments::{
MetricsBucketResponse, PaymentDimensions, PaymentDistributions, PaymentMetrics,
PaymentMetricsBucketIdentifier,
},
FilterValue, GetPaymentFiltersRequest, GetPaymentMetricRequest, PaymentFiltersResponse,
PaymentsAnalyticsMetadata, PaymentsMetricsResponse,
};
use common_enums::Currency;
use router_env::{
instrument, logger,
tracing::{self, Instrument},
};
use super::{
distribution::PaymentDistributionRow,
filters::{get_payment_filter_for_dimension, PaymentFilterRow},
metrics::PaymentMetricRow,
PaymentMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
payments::{PaymentDistributionAccumulator, PaymentMetricAccumulator},
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetPaymentFiltersRequest,
auth: &AuthInfo,
) -> AnalyticsResult<PaymentFiltersResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/core.rs | crate: analytics
use std::collections::{HashMap, HashSet};
use api_models::analytics::{
payments::{
MetricsBucketResponse, PaymentDimensions, PaymentDistributions, PaymentMetrics,
PaymentMetricsBucketIdentifier,
},
FilterValue, GetPaymentFiltersRequest, GetPaymentMetricRequest, PaymentFiltersResponse,
PaymentsAnalyticsMetadata, PaymentsMetricsResponse,
};
use common_enums::Currency;
use currency_conversion::{conversion::convert, types::ExchangeRates};
use router_env::{
instrument, logger,
tracing::{self, Instrument},
};
use super::{
distribution::PaymentDistributionRow,
filters::{get_payment_filter_for_dimension, PaymentFilterRow},
metrics::PaymentMetricRow,
PaymentMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
payments::{PaymentDistributionAccumulator, PaymentMetricAccumulator},
AnalyticsProvider,
};
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetPaymentMetricRequest,
) -> AnalyticsResult<PaymentsMetricsResponse<MetricsBucketResponse>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/payments/filters.rs | crate: analytics
use api_models::analytics::{payments::PaymentDimensions, Granularity, TimeRange};
use time::PrimitiveDateTime;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, FiltersError, FiltersResult,
LoadRow,
},
};
pub async fn get_payment_filter_for_dimension<T>(
dimension: PaymentDimensions,
auth: &AuthInfo,
time_range: &TimeRange,
pool: &T,
) -> FiltersResult<Vec<PaymentFilterRow>>
where
T: AnalyticsDataSource + PaymentFilterAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
let mut query_builder: QueryBuilder<T> = QueryBuilder::new(AnalyticsCollection::Payment);
query_builder.add_select_column(dimension).switch()?;
time_range
.set_filter_clause(&mut query_builder)
.attach_printable("Error filtering time range")
.switch()?;
auth.set_filter_clause(&mut query_builder).switch()?;
query_builder.set_distinct();
query_builder
.execute_query::<PaymentFilterRow, _>(pool)
.await
.change_context(FiltersError::QueryBuildingError)?
.change_context(FiltersError::QueryExecutionFailure)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/filters.rs | crate: analytics
use api_models::analytics::{payments::PaymentDimensions, Granularity, TimeRange};
use time::PrimitiveDateTime;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, FiltersError, FiltersResult,
LoadRow,
},
};
pub async fn get_payment_filter_for_dimension<T>(
dimension: PaymentDimensions,
auth: &AuthInfo,
time_range: &TimeRange,
pool: &T,
) -> FiltersResult<Vec<PaymentFilterRow>>
where
T: AnalyticsDataSource + PaymentFilterAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/accumulator.rs | crate: analytics
use api_models::analytics::payments::{ErrorResult, PaymentMetricsBucketValue};
pub fn collect(self) -> PaymentMetricsBucketValue {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/accumulator.rs | crate: analytics
use bigdecimal::ToPrimitive;
use router_env::logger;
use super::{distribution::PaymentDistributionRow, metrics::PaymentMetricRow};
fn add_metrics_bucket(&mut self, metrics: &PaymentMetricRow) {
{
(Some(total), Some(count)) => {
self.total += total;
self.count += count;
}<|fim_suffix|>
<|fim_middle|>
_ => {
logger::error!(message="Dropping metrics for average accumulator", metric=?metrics);
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/accumulator.rs | crate: analytics
use bigdecimal::ToPrimitive;
use super::{distribution::PaymentDistributionRow, metrics::PaymentMetricRow};
fn add_metrics_bucket(&mut self, metrics: &PaymentMetricRow) {
{
(None, None) => None,<|fim_suffix|>
<|fim_middle|>
(Some(a), Some(b)) => Some(a + b),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/accumulator.rs | crate: analytics
use bigdecimal::ToPrimitive;
use router_env::logger;
use super::{distribution::PaymentDistributionRow, metrics::PaymentMetricRow};
fn add_metrics_bucket(&mut self, metrics: &PaymentMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/accumulator.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/accumulator.rs | crate: analytics
use super::{distribution::PaymentDistributionRow, metrics::PaymentMetricRow};
fn add_distribution_bucket(&mut self, distribution: &PaymentDistributionRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/distribution/payment_error_message.rs | crate: analytics
use api_models::analytics::{
payments::{PaymentDimensions, PaymentFilters, PaymentMetricsBucketIdentifier},
Granularity, PaymentDistributionBody, TimeRange,
};
use diesel_models::enums as storage_enums;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::{PaymentDistribution, PaymentDistributionRow};
use crate::{
enums::AuthInfo,
query::{
Aggregate, GroupByClause, Order, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window,
},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_distribution(
&self,
distribution: &PaymentDistributionBody,
dimensions: &[PaymentDimensions],
auth: &AuthInfo,
filters: &PaymentFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<Vec<(PaymentMetricsBucketIdentifier, PaymentDistributionRow)>> {
{
(Some(g), Some(st)) => g.clip_to_start(st)?,<|fim_suffix|>
<|fim_middle|>
_ => time_range.start_time,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payments/distribution/payment_error_message.rs | crate: analytics
use api_models::analytics::{
payments::{PaymentDimensions, PaymentFilters, PaymentMetricsBucketIdentifier},
Granularity, PaymentDistributionBody, TimeRange,
};
use diesel_models::enums as storage_enums;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::{PaymentDistribution, PaymentDistributionRow};
use crate::{
enums::AuthInfo,
query::{
Aggregate, GroupByClause, Order, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window,
},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_distribution(
&self,
distribution: &PaymentDistributionBody,
dimensions: &[PaymentDimensions],
auth: &AuthInfo,
filters: &PaymentFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<Vec<(PaymentMetricsBucketIdentifier, PaymentDistributionRow)>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/connector_events/core.rs | crate: analytics
use api_models::analytics::connector_events::ConnectorEventsRequest;
use common_utils::errors::ReportSwitchExt;
use super::events::{get_connector_events, ConnectorEventsResult};
use crate::{errors::AnalyticsResult, types::FiltersError, AnalyticsProvider};
pub async fn connector_events_core(
pool: &AnalyticsProvider,
req: ConnectorEventsRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<Vec<ConnectorEventsResult>> {
{
AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented(
"Connector Events not implemented for SQLX",
))
.attach_printable("SQL Analytics is not implemented for Connector Events"),<|fim_suffix|>
<|fim_middle|>
AnalyticsProvider::Clickhouse(ckh_pool)
| AnalyticsProvider::CombinedSqlx(_, ckh_pool)
| AnalyticsProvider::CombinedCkh(_, ckh_pool) => {
get_connector_events(merchant_id, req, ckh_pool).await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/connector_events/core.rs | crate: analytics
use api_models::analytics::connector_events::ConnectorEventsRequest;
use common_utils::errors::ReportSwitchExt;
use super::events::{get_connector_events, ConnectorEventsResult};
use crate::{errors::AnalyticsResult, types::FiltersError, AnalyticsProvider};
pub async fn connector_events_core(
pool: &AnalyticsProvider,
req: ConnectorEventsRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<Vec<ConnectorEventsResult>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/core.rs | crate: analytics
use std::collections::HashMap;
use api_models::analytics::{
api_event::{
ApiEventMetricsBucketIdentifier, ApiEventMetricsBucketValue, ApiLogsRequest,
ApiMetricsBucketResponse,
},
AnalyticsMetadata, ApiEventFiltersResponse, GetApiEventFiltersRequest,
GetApiEventMetricRequest, MetricsResponse,
};
use common_utils::errors::ReportSwitchExt;
use error_stack::ResultExt;
use router_env::{
instrument, logger,
tracing::{self, Instrument},
};
use super::{
events::{get_api_event, ApiLogsResult},
metrics::ApiEventMetricRow,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
metrics,
types::FiltersError,
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetApiEventFiltersRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<ApiEventFiltersResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/core.rs | crate: analytics
))
.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
}
}
.switch()?;
Ok(data)
}
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetApiEventFiltersRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<ApiEventFiltersResponse> {
use api_models::analytics::{api_event::ApiEventDimensions, ApiEventFilterValue};
use super::filters::get_api_event_filter_for_dimension;
use crate::api_event::filters::ApiEventFilter;
let mut res = ApiEventFiltersResponse::default();
for dim in req.group_by_names {
let values = match pool {
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetApiEventFiltersRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<ApiEventFiltersResponse> {
{
ApiEventDimensions::StatusCode => fil.status_code.map(|i| i.to_string()),<|fim_suffix|>
<|fim_middle|>
ApiEventDimensions::ApiFlow => fil.api_flow,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/core.rs | crate: analytics
use api_models::analytics::{
api_event::{
ApiEventMetricsBucketIdentifier, ApiEventMetricsBucketValue, ApiLogsRequest,
ApiMetricsBucketResponse,
},
AnalyticsMetadata, ApiEventFiltersResponse, GetApiEventFiltersRequest,
GetApiEventMetricRequest, MetricsResponse,
};
use common_utils::errors::ReportSwitchExt;
use super::{
events::{get_api_event, ApiLogsResult},
metrics::ApiEventMetricRow,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
metrics,
types::FiltersError,
AnalyticsProvider,
};
pub async fn api_events_core(
pool: &AnalyticsProvider,
req: ApiLogsRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<Vec<ApiLogsResult>> {
{
AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented(
"API Events not implemented for SQLX",
))
.attach_printable("SQL Analytics is not implemented for API Events"),<|fim_suffix|>
<|fim_middle|>
AnalyticsProvider::CombinedSqlx(_sqlx_pool, ckh_pool)
| AnalyticsProvider::CombinedCkh(_sqlx_pool, ckh_pool) => {
get_api_event(merchant_id, req, ckh_pool).await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/core.rs | crate: analytics
use api_models::analytics::{
api_event::{
ApiEventMetricsBucketIdentifier, ApiEventMetricsBucketValue, ApiLogsRequest,
ApiMetricsBucketResponse,
},
AnalyticsMetadata, ApiEventFiltersResponse, GetApiEventFiltersRequest,
GetApiEventMetricRequest, MetricsResponse,
};
use common_utils::errors::ReportSwitchExt;
use super::{
events::{get_api_event, ApiLogsResult},
metrics::ApiEventMetricRow,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
metrics,
types::FiltersError,
AnalyticsProvider,
};
pub async fn api_events_core(
pool: &AnalyticsProvider,
req: ApiLogsRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<Vec<ApiLogsResult>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/core.rs | crate: analytics
use std::collections::HashMap;
use api_models::analytics::{
api_event::{
ApiEventMetricsBucketIdentifier, ApiEventMetricsBucketValue, ApiLogsRequest,
ApiMetricsBucketResponse,
},
AnalyticsMetadata, ApiEventFiltersResponse, GetApiEventFiltersRequest,
GetApiEventMetricRequest, MetricsResponse,
};
use common_utils::errors::ReportSwitchExt;
use router_env::{
instrument, logger,
tracing::{self, Instrument},
};
use super::{
events::{get_api_event, ApiLogsResult},
metrics::ApiEventMetricRow,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
metrics,
types::FiltersError,
AnalyticsProvider,
};
pub async fn get_api_event_metrics(
pool: &AnalyticsProvider,
merchant_id: &common_utils::id_type::MerchantId,
req: GetApiEventMetricRequest,
) -> AnalyticsResult<MetricsResponse<ApiMetricsBucketResponse>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/api_event/filters.rs | crate: analytics
use api_models::analytics::{api_event::ApiEventDimensions, Granularity, TimeRange};
use common_utils::errors::ReportSwitchExt;
use time::PrimitiveDateTime;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, FiltersError, FiltersResult, LoadRow},
};
pub async fn get_api_event_filter_for_dimension<T>(
dimension: ApiEventDimensions,
merchant_id: &common_utils::id_type::MerchantId,
time_range: &TimeRange,
pool: &T,
) -> FiltersResult<Vec<ApiEventFilter>>
where
T: AnalyticsDataSource + ApiEventFilterAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
let mut query_builder: QueryBuilder<T> = QueryBuilder::new(AnalyticsCollection::ApiEvents);
query_builder.add_select_column(dimension).switch()?;
time_range
.set_filter_clause(&mut query_builder)
.attach_printable("Error filtering time range")
.switch()?;
query_builder
.add_filter_clause("merchant_id", merchant_id)
.switch()?;
query_builder.set_distinct();
query_builder
.execute_query::<ApiEventFilter, _>(pool)
.await
.change_context(FiltersError::QueryBuildingError)?
.change_context(FiltersError::QueryExecutionFailure)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/filters.rs | crate: analytics
use api_models::analytics::{api_event::ApiEventDimensions, Granularity, TimeRange};
use common_utils::errors::ReportSwitchExt;
use time::PrimitiveDateTime;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, FiltersError, FiltersResult, LoadRow},
};
pub async fn get_api_event_filter_for_dimension<T>(
dimension: ApiEventDimensions,
merchant_id: &common_utils::id_type::MerchantId,
time_range: &TimeRange,
pool: &T,
) -> FiltersResult<Vec<ApiEventFilter>>
where
T: AnalyticsDataSource + ApiEventFilterAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/metrics/api_count.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
api_event::{ApiEventDimensions, ApiEventFilters, ApiEventMetricsBucketIdentifier},
Granularity, TimeRange,
};
use common_utils::errors::ReportSwitchExt;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::ApiEventMetricRow;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
_dimensions: &[ApiEventDimensions],
merchant_id: &common_utils::id_type::MerchantId,
filters: &ApiEventFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(ApiEventMetricsBucketIdentifier, ApiEventMetricRow)>> {
{
(Some(g), Some(st)) => g.clip_to_start(st)?,<|fim_suffix|>
<|fim_middle|>
_ => time_range.start_time,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/api_event/metrics/api_count.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
api_event::{ApiEventDimensions, ApiEventFilters, ApiEventMetricsBucketIdentifier},
Granularity, TimeRange,
};
use common_utils::errors::ReportSwitchExt;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::ApiEventMetricRow;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
_dimensions: &[ApiEventDimensions],
merchant_id: &common_utils::id_type::MerchantId,
filters: &ApiEventFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(ApiEventMetricsBucketIdentifier, ApiEventMetricRow)>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/core.rs | crate: analytics
Some(total_payment_processed_amount_without_smart_retries_in_usd)
} else {
None
},
total_payment_processed_count: Some(total_payment_processed_count),
total_payment_processed_count_without_smart_retries: Some(
total_payment_processed_count_without_smart_retries,
),
}],
})
}
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetPaymentIntentFiltersRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<PaymentIntentFiltersResponse> {
let mut res = PaymentIntentFiltersResponse::default();
for dim in req.group_by_names {
let values = match pool {
AnalyticsProvider::Sqlx(pool) => {
get_payment_intent_filter_for_dimension(dim, merchant_id, &req.time_range, pool)
.await
}
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetPaymentIntentFiltersRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<PaymentIntentFiltersResponse> {
{
PaymentIntentDimensions::PaymentIntentStatus => fil.status.map(|i| i.as_ref().to_string()),<|fim_suffix|>
<|fim_middle|>
PaymentIntentDimensions::ErrorReason => fil.error_reason,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/core.rs | crate: analytics
AnalyticsProvider::Clickhouse(ckh_pool)
| AnalyticsProvider::CombinedCkh(_, ckh_pool)
| AnalyticsProvider::CombinedSqlx(_, ckh_pool) => {
let sankey_rows = get_sankey_data(ckh_pool, auth, &req)
.await
.change_context(AnalyticsError::UnknownError)?;
Ok(sankey_rows)
}
}
}
#[instrument(skip_all)]
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetPaymentIntentMetricRequest,
) -> AnalyticsResult<PaymentIntentsMetricsResponse<MetricsBucketResponse>> {
let mut metrics_accumulator: HashMap<
PaymentIntentMetricsBucketIdentifier,
PaymentIntentMetricsAccumulator,
> = HashMap::new();
let mut set = tokio::task::JoinSet::new();
for metric_type in req.metrics.iter().cloned() {
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetPaymentIntentMetricRequest,
) -> AnalyticsResult<PaymentIntentsMetricsResponse<MetricsBucketResponse>> {
{
(s, t) if t > 0 => Some(f64::from(s) * 100.0 / f64::from(t)),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/core.rs | crate: analytics
use common_utils::{errors::CustomResult, types::TimeRange};
use super::{
filters::{get_payment_intent_filter_for_dimension, PaymentIntentFilterRow},
metrics::PaymentIntentMetricRow,
sankey::{get_sankey_data, SankeyRow},
PaymentIntentMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
payment_intents::PaymentIntentMetricAccumulator,
AnalyticsProvider,
};
pub async fn get_sankey(
pool: &AnalyticsProvider,
auth: &AuthInfo,
req: TimeRange,
) -> AnalyticsResult<Vec<SankeyRow>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/core.rs | crate: analytics
use api_models::analytics::{
payment_intents::{
MetricsBucketResponse, PaymentIntentDimensions, PaymentIntentMetrics,
PaymentIntentMetricsBucketIdentifier,
},
GetPaymentIntentFiltersRequest, GetPaymentIntentMetricRequest, PaymentIntentFilterValue,
PaymentIntentFiltersResponse, PaymentIntentsAnalyticsMetadata, PaymentIntentsMetricsResponse,
};
use common_enums::Currency;
use common_utils::{errors::CustomResult, types::TimeRange};
use router_env::{
instrument, logger,
tracing::{self, Instrument},
};
use super::{
filters::{get_payment_intent_filter_for_dimension, PaymentIntentFilterRow},
metrics::PaymentIntentMetricRow,
sankey::{get_sankey_data, SankeyRow},
PaymentIntentMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
payment_intents::PaymentIntentMetricAccumulator,
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetPaymentIntentFiltersRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<PaymentIntentFiltersResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/core.rs | crate: analytics
use std::collections::{HashMap, HashSet};
use api_models::analytics::{
payment_intents::{
MetricsBucketResponse, PaymentIntentDimensions, PaymentIntentMetrics,
PaymentIntentMetricsBucketIdentifier,
},
GetPaymentIntentFiltersRequest, GetPaymentIntentMetricRequest, PaymentIntentFilterValue,
PaymentIntentFiltersResponse, PaymentIntentsAnalyticsMetadata, PaymentIntentsMetricsResponse,
};
use common_enums::Currency;
use currency_conversion::{conversion::convert, types::ExchangeRates};
use router_env::{
instrument, logger,
tracing::{self, Instrument},
};
use super::{
filters::{get_payment_intent_filter_for_dimension, PaymentIntentFilterRow},
metrics::PaymentIntentMetricRow,
sankey::{get_sankey_data, SankeyRow},
PaymentIntentMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
payment_intents::PaymentIntentMetricAccumulator,
AnalyticsProvider,
};
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetPaymentIntentMetricRequest,
) -> AnalyticsResult<PaymentIntentsMetricsResponse<MetricsBucketResponse>> {
{let mut metrics_accumulator: HashMap<
PaymentIntentMetricsBucketIdentifier,
PaymentIntentMetricsAccumulator,
> = HashMap::new();<|fim_suffix|>
<|fim_middle|>
Ok(PaymentIntentsMetricsResponse {
query_data,
meta_data: [PaymentIntentsAnalyticsMetadata {
total_success_rate,
total_success_rate_without_smart_retries,
total_smart_retried_amount: Some(total_smart_retried_amount),
total_smart_retried_amount_without_smart_retries: Some(
total_smart_retried_amount_without_smart_retries,
),
total_payment_processed_amount: Some(total_payment_processed_amount),
total_payment_processed_amount_without_smart_retries: Some(
total_payment_processed_amount_without_smart_retries,
),
total_smart_retried_amount_in_usd: if ex_rates.is_some() {
Some(total_smart_retried_amount_in_usd)
} else {
None
},
total_smart_retried_amount_without_smart_retries_in_usd: if ex_rates.is_some() {
Some(total_smart_retried_amount_without_smart_retries_in_usd)
} else {
None
},
total_payment_processed_amount_in_usd: if ex_rates.is_some() {
Some(total_payment_processed_amount_in_usd)
} else {
None
},
total_payment_processed_amount_without_smart_retries_in_usd: if ex_rates.is_some() {
Some(total_payment_processed_amount_without_smart_retries_in_usd)
} else {
None
},
total_payment_processed_count: Some(total_payment_processed_count),
total_payment_processed_count_without_smart_retries: Some(
total_payment_processed_count_without_smart_retries,
),
}],
})}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/accumulator.rs | crate: analytics
use api_models::analytics::payment_intents::PaymentIntentMetricsBucketValue;
pub fn collect(self) -> PaymentIntentMetricsBucketValue {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/accumulator.rs | crate: analytics
use diesel_models::enums as storage_enums;
use super::metrics::PaymentIntentMetricRow;
fn add_metrics_bucket(&mut self, metrics: &PaymentIntentMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/accumulator.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
{
(Some(s), Some(t)) if t > 0 => Some(f64::from(s) * 100.0 / f64::from(t)),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/payment_intents/metrics/payment_intent_count.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
payment_intents::{
PaymentIntentDimensions, PaymentIntentFilters, PaymentIntentMetricsBucketIdentifier,
},
Granularity, TimeRange,
};
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::PaymentIntentMetricRow;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[PaymentIntentDimensions],
auth: &AuthInfo,
filters: &PaymentIntentFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(PaymentIntentMetricsBucketIdentifier, PaymentIntentMetricRow)>>
{
{
(Some(g), Some(st)) => g.clip_to_start(st)?,<|fim_suffix|>
<|fim_middle|>
_ => time_range.start_time,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/active_payments/accumulator.rs | crate: analytics
use super::metrics::ActivePaymentsMetricRow;
fn add_metrics_bucket(&mut self, metrics: &ActivePaymentsMetricRow) {
{
(None, None) => None,<|fim_suffix|>
<|fim_middle|>
(Some(a), Some(b)) => Some(a + b),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/active_payments/accumulator.rs | crate: analytics
use api_models::analytics::active_payments::ActivePaymentsMetricsBucketValue;
pub fn collect(self) -> ActivePaymentsMetricsBucketValue {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/active_payments/accumulator.rs | crate: analytics
use super::metrics::ActivePaymentsMetricRow;
fn add_metrics_bucket(&mut self, metrics: &ActivePaymentsMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/core.rs | crate: analytics
use std::collections::HashMap;
use api_models::analytics::{
sdk_events::{
MetricsBucketResponse, SdkEventMetrics, SdkEventMetricsBucketIdentifier, SdkEventsRequest,
},
AnalyticsMetadata, GetSdkEventFiltersRequest, GetSdkEventMetricRequest, MetricsResponse,
SdkEventFiltersResponse,
};
use common_utils::errors::ReportSwitchExt;
use error_stack::ResultExt;
use router_env::{instrument, logger, tracing};
use super::{
events::{get_sdk_event, SdkEventsResult},
SdkEventMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
sdk_events::SdkEventMetricAccumulator,
types::FiltersError,
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetSdkEventFiltersRequest,
publishable_key: &String,
) -> AnalyticsResult<SdkEventFiltersResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/core.rs | crate: analytics
})
.collect();
Ok(MetricsResponse {
query_data,
meta_data: [AnalyticsMetadata {
current_time_range: req.time_range,
}],
})
}
#[allow(dead_code)]
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetSdkEventFiltersRequest,
publishable_key: &String,
) -> AnalyticsResult<SdkEventFiltersResponse> {
use api_models::analytics::{sdk_events::SdkEventDimensions, SdkEventFilterValue};
use super::filters::get_sdk_event_filter_for_dimension;
use crate::sdk_events::filters::SdkEventFilter;
let mut res = SdkEventFiltersResponse::default();
for dim in req.group_by_names {
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetSdkEventFiltersRequest,
publishable_key: &String,
) -> AnalyticsResult<SdkEventFiltersResponse> {
{
AnalyticsProvider::Sqlx(_pool) => Err(FiltersError::NotImplemented(
"SDK Events not implemented for SQLX",
))
.attach_printable("SQL Analytics is not implemented for SDK Events"),<|fim_suffix|>
<|fim_middle|>
AnalyticsProvider::CombinedSqlx(_sqlx_pool, ckh_pool)
| AnalyticsProvider::CombinedCkh(_sqlx_pool, ckh_pool) => {
get_sdk_event_filter_for_dimension(dim, publishable_key, &req.time_range, ckh_pool)
.await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/core.rs | crate: analytics
use api_models::analytics::{
sdk_events::{
MetricsBucketResponse, SdkEventMetrics, SdkEventMetricsBucketIdentifier, SdkEventsRequest,
},
AnalyticsMetadata, GetSdkEventFiltersRequest, GetSdkEventMetricRequest, MetricsResponse,
SdkEventFiltersResponse,
};
use super::{
events::{get_sdk_event, SdkEventsResult},
SdkEventMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
sdk_events::SdkEventMetricAccumulator,
types::FiltersError,
AnalyticsProvider,
};
pub async fn sdk_events_core(
pool: &AnalyticsProvider,
req: SdkEventsRequest,
publishable_key: &String,
) -> AnalyticsResult<Vec<SdkEventsResult>> {
{
AnalyticsProvider::Sqlx(_) => Err(FiltersError::NotImplemented(
"SDK Events not implemented for SQLX",
))
.attach_printable("SQL Analytics is not implemented for Sdk Events"),<|fim_suffix|>
<|fim_middle|>
AnalyticsProvider::CombinedSqlx(_sqlx_pool, ckh_pool)
| AnalyticsProvider::CombinedCkh(_sqlx_pool, ckh_pool) => {
get_sdk_event(publishable_key, req, ckh_pool).await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/core.rs | crate: analytics
use api_models::analytics::{
sdk_events::{
MetricsBucketResponse, SdkEventMetrics, SdkEventMetricsBucketIdentifier, SdkEventsRequest,
},
AnalyticsMetadata, GetSdkEventFiltersRequest, GetSdkEventMetricRequest, MetricsResponse,
SdkEventFiltersResponse,
};
use super::{
events::{get_sdk_event, SdkEventsResult},
SdkEventMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
sdk_events::SdkEventMetricAccumulator,
types::FiltersError,
AnalyticsProvider,
};
pub async fn sdk_events_core(
pool: &AnalyticsProvider,
req: SdkEventsRequest,
publishable_key: &String,
) -> AnalyticsResult<Vec<SdkEventsResult>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/core.rs | crate: analytics
use std::collections::HashMap;
use api_models::analytics::{
sdk_events::{
MetricsBucketResponse, SdkEventMetrics, SdkEventMetricsBucketIdentifier, SdkEventsRequest,
},
AnalyticsMetadata, GetSdkEventFiltersRequest, GetSdkEventMetricRequest, MetricsResponse,
SdkEventFiltersResponse,
};
use router_env::{instrument, logger, tracing};
use super::{
events::{get_sdk_event, SdkEventsResult},
SdkEventMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
sdk_events::SdkEventMetricAccumulator,
types::FiltersError,
AnalyticsProvider,
};
pub async fn get_metrics(
pool: &AnalyticsProvider,
publishable_key: &String,
req: GetSdkEventMetricRequest,
) -> AnalyticsResult<MetricsResponse<MetricsBucketResponse>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/accumulator.rs | crate: analytics
use router_env::logger;
use super::metrics::SdkEventMetricRow;
fn add_metrics_bucket(&mut self, metrics: &SdkEventMetricRow) {
{
(Some(total), Some(count)) => {
self.total += total;
self.count += count;
}<|fim_suffix|>
<|fim_middle|>
_ => {
logger::error!(message="Dropping metrics for average accumulator", metric=?metrics);
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/accumulator.rs | crate: analytics
use api_models::analytics::sdk_events::SdkEventMetricsBucketValue;
pub fn collect(self) -> SdkEventMetricsBucketValue {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/sdk_events/accumulator.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
if self.count == 0 {
None
} else {
Some(f64::from(self.total) / f64::from(self.count))
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sdk_events/accumulator.rs | crate: analytics
use router_env::logger;
use super::metrics::SdkEventMetricRow;
fn add_metrics_bucket(&mut self, metrics: &SdkEventMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/metrics.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
disputes::{DisputeDimensions, DisputeFilters, DisputeMetrics, DisputeMetricsBucketIdentifier},
Granularity,
};
use common_utils::types::TimeRange;
use self::{
dispute_status_metric::DisputeStatusMetric, total_amount_disputed::TotalAmountDisputed,
total_dispute_lost_amount::TotalDisputeLostAmount,
};
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[DisputeDimensions],
auth: &AuthInfo,
filters: &DisputeFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(DisputeMetricsBucketIdentifier, DisputeMetricRow)>> {
{
Self::TotalAmountDisputed => {
TotalAmountDisputed::default()
.load_metrics(dimensions, auth, filters, granularity, time_range, pool)
.await
}<|fim_suffix|>
<|fim_middle|>
Self::SessionizedTotalDisputeLostAmount => {
sessionized_metrics::TotalDisputeLostAmount::default()
.load_metrics(dimensions, auth, filters, granularity, time_range, pool)
.await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/metrics.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
disputes::{DisputeDimensions, DisputeFilters, DisputeMetrics, DisputeMetricsBucketIdentifier},
Granularity,
};
use common_utils::types::TimeRange;
use self::{
dispute_status_metric::DisputeStatusMetric, total_amount_disputed::TotalAmountDisputed,
total_dispute_lost_amount::TotalDisputeLostAmount,
};
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[DisputeDimensions],
auth: &AuthInfo,
filters: &DisputeFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(DisputeMetricsBucketIdentifier, DisputeMetricRow)>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/accumulators.rs | crate: analytics
use api_models::analytics::disputes::DisputeMetricsBucketValue;
pub fn collect(self) -> DisputeMetricsBucketValue {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/accumulators.rs | crate: analytics
use super::metrics::DisputeMetricRow;
fn add_metrics_bucket(&mut self, metrics: &DisputeMetricRow) {
{
(None, None) => None,<|fim_suffix|>
<|fim_middle|>
(Some(a), Some(b)) => Some(a + b),
}
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/disputes/accumulators.rs | crate: analytics
use api_models::analytics::disputes::DisputeMetricsBucketValue;
pub fn collect(self) -> DisputeMetricsBucketValue {
let (challenge_rate, won_rate, lost_rate, total_dispute) =
self.disputes_status_rate.collect().unwrap_or_default();
DisputeMetricsBucketValue {
disputes_challenged: challenge_rate,
disputes_won: won_rate,
disputes_lost: lost_rate,
disputed_amount: self.disputed_amount.collect(),
dispute_lost_amount: self.dispute_lost_amount.collect(),
total_dispute,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/accumulators.rs | crate: analytics
use diesel_models::enums as storage_enums;
use super::metrics::DisputeMetricRow;
fn add_metrics_bucket(&mut self, metrics: &DisputeMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/disputes/accumulators.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
self.total.and_then(|i| u64::try_from(i).ok())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/metrics/total_dispute_lost_amount.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
disputes::{DisputeDimensions, DisputeFilters, DisputeMetricsBucketIdentifier},
Granularity, TimeRange,
};
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::DisputeMetricRow;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[DisputeDimensions],
auth: &AuthInfo,
filters: &DisputeFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(DisputeMetricsBucketIdentifier, DisputeMetricRow)>>
where
T: AnalyticsDataSource + super::DisputeMetricAnalytics,
{
{
(Some(g), Some(st)) => g.clip_to_start(st)?,<|fim_suffix|>
<|fim_middle|>
_ => time_range.start_time,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/disputes/metrics/total_dispute_lost_amount.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
disputes::{DisputeDimensions, DisputeFilters, DisputeMetricsBucketIdentifier},
Granularity, TimeRange,
};
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::DisputeMetricRow;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[DisputeDimensions],
auth: &AuthInfo,
filters: &DisputeFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(DisputeMetricsBucketIdentifier, DisputeMetricRow)>>
where
T: AnalyticsDataSource + super::DisputeMetricAnalytics,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/core.rs | crate: analytics
use api_models::analytics::{
frm::{FrmDimensions, FrmMetrics, FrmMetricsBucketIdentifier, FrmMetricsBucketResponse},
AnalyticsMetadata, FrmFilterValue, FrmFiltersResponse, GetFrmFilterRequest,
GetFrmMetricRequest, MetricsResponse,
};
use router_env::{
logger,
tracing::{self, Instrument},
};
use super::{
filters::{get_frm_filter_for_dimension, FrmFilterRow},
FrmMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
frm::FrmMetricAccumulator,
metrics, AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetFrmFilterRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<FrmFiltersResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/core.rs | crate: analytics
use api_models::analytics::{
frm::{FrmDimensions, FrmMetrics, FrmMetricsBucketIdentifier, FrmMetricsBucketResponse},
AnalyticsMetadata, FrmFilterValue, FrmFiltersResponse, GetFrmFilterRequest,
GetFrmMetricRequest, MetricsResponse,
};
use router_env::{
logger,
tracing::{self, Instrument},
};
use super::{
filters::{get_frm_filter_for_dimension, FrmFilterRow},
FrmMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
frm::FrmMetricAccumulator,
metrics, AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetFrmFilterRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<FrmFiltersResponse> {
{
FrmDimensions::FrmStatus => fil.frm_status.map(|i| i.as_ref().to_string()),<|fim_suffix|>
<|fim_middle|>
FrmDimensions::FrmTransactionType => {
fil.frm_transaction_type.map(|i| i.as_ref().to_string())
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/core.rs | crate: analytics
use std::collections::HashMap;
use api_models::analytics::{
frm::{FrmDimensions, FrmMetrics, FrmMetricsBucketIdentifier, FrmMetricsBucketResponse},
AnalyticsMetadata, FrmFilterValue, FrmFiltersResponse, GetFrmFilterRequest,
GetFrmMetricRequest, MetricsResponse,
};
use router_env::{
logger,
tracing::{self, Instrument},
};
use super::{
filters::{get_frm_filter_for_dimension, FrmFilterRow},
FrmMetricsAccumulator,
};
use crate::{
errors::{AnalyticsError, AnalyticsResult},
frm::FrmMetricAccumulator,
metrics, AnalyticsProvider,
};
pub async fn get_metrics(
pool: &AnalyticsProvider,
merchant_id: &common_utils::id_type::MerchantId,
req: GetFrmMetricRequest,
) -> AnalyticsResult<MetricsResponse<FrmMetricsBucketResponse>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/frm/filters.rs | crate: analytics
use api_models::analytics::{
frm::{FrmDimensions, FrmTransactionType},
Granularity, TimeRange,
};
use common_utils::errors::ReportSwitchExt;
use time::PrimitiveDateTime;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, FiltersError, FiltersResult,
LoadRow,
},
};
pub async fn get_frm_filter_for_dimension<T>(
dimension: FrmDimensions,
merchant_id: &common_utils::id_type::MerchantId,
time_range: &TimeRange,
pool: &T,
) -> FiltersResult<Vec<FrmFilterRow>>
where
T: AnalyticsDataSource + FrmFilterAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
let mut query_builder: QueryBuilder<T> = QueryBuilder::new(AnalyticsCollection::FraudCheck);
query_builder.add_select_column(dimension).switch()?;
time_range
.set_filter_clause(&mut query_builder)
.attach_printable("Error filtering time range")
.switch()?;
query_builder
.add_filter_clause("merchant_id", merchant_id)
.switch()?;
query_builder.set_distinct();
query_builder
.execute_query::<FrmFilterRow, _>(pool)
.await
.change_context(FiltersError::QueryBuildingError)?
.change_context(FiltersError::QueryExecutionFailure)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/filters.rs | crate: analytics
use api_models::analytics::{
frm::{FrmDimensions, FrmTransactionType},
Granularity, TimeRange,
};
use common_utils::errors::ReportSwitchExt;
use time::PrimitiveDateTime;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, FiltersError, FiltersResult,
LoadRow,
},
};
pub async fn get_frm_filter_for_dimension<T>(
dimension: FrmDimensions,
merchant_id: &common_utils::id_type::MerchantId,
time_range: &TimeRange,
pool: &T,
) -> FiltersResult<Vec<FrmFilterRow>>
where
T: AnalyticsDataSource + FrmFilterAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/accumulator.rs | crate: analytics
use super::metrics::FrmMetricRow;
fn add_metrics_bucket(&mut self, metrics: &FrmMetricRow) {
{
(None, None) => None,<|fim_suffix|>
<|fim_middle|>
(Some(a), Some(b)) => Some(a + b),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/accumulator.rs | crate: analytics
use api_models::analytics::frm::FrmMetricsBucketValue;
pub fn collect(self) -> FrmMetricsBucketValue {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/frm/accumulator.rs | crate: analytics
use common_enums::enums as storage_enums;
use super::metrics::FrmMetricRow;
fn add_metrics_bucket(&mut self, metrics: &FrmMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/auth_events/core.rs | crate: analytics
use api_models::analytics::{
auth_events::{
AuthEventDimensions, AuthEventMetrics, AuthEventMetricsBucketIdentifier,
MetricsBucketResponse,
},
AuthEventFilterValue, AuthEventFiltersResponse, AuthEventMetricsResponse,
AuthEventsAnalyticsMetadata, GetAuthEventFilterRequest, GetAuthEventMetricRequest,
};
use error_stack::{report, ResultExt};
use router_env::{instrument, tracing};
use super::{
filters::{get_auth_events_filter_for_dimension, AuthEventFilterRow},
AuthEventMetricsAccumulator,
};
use crate::{
auth_events::AuthEventMetricAccumulator,
errors::{AnalyticsError, AnalyticsResult},
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetAuthEventFilterRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<AuthEventFiltersResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/auth_events/core.rs | crate: analytics
use api_models::analytics::{
auth_events::{
AuthEventDimensions, AuthEventMetrics, AuthEventMetricsBucketIdentifier,
MetricsBucketResponse,
},
AuthEventFilterValue, AuthEventFiltersResponse, AuthEventMetricsResponse,
AuthEventsAnalyticsMetadata, GetAuthEventFilterRequest, GetAuthEventMetricRequest,
};
use error_stack::{report, ResultExt};
use router_env::{instrument, tracing};
use super::{
filters::{get_auth_events_filter_for_dimension, AuthEventFilterRow},
AuthEventMetricsAccumulator,
};
use crate::{
auth_events::AuthEventMetricAccumulator,
errors::{AnalyticsError, AnalyticsResult},
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetAuthEventFilterRequest,
merchant_id: &common_utils::id_type::MerchantId,
) -> AnalyticsResult<AuthEventFiltersResponse> {
{
AuthEventDimensions::AuthenticationStatus => fil.authentication_status.map(|i| i.as_ref().to_string()),<|fim_suffix|>
<|fim_middle|>
AuthEventDimensions::AcsReferenceNumber => fil.acs_reference_number,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/auth_events/core.rs | crate: analytics
use std::collections::HashMap;
use api_models::analytics::{
auth_events::{
AuthEventDimensions, AuthEventMetrics, AuthEventMetricsBucketIdentifier,
MetricsBucketResponse,
},
AuthEventFilterValue, AuthEventFiltersResponse, AuthEventMetricsResponse,
AuthEventsAnalyticsMetadata, GetAuthEventFilterRequest, GetAuthEventMetricRequest,
};
use super::{
filters::{get_auth_events_filter_for_dimension, AuthEventFilterRow},
AuthEventMetricsAccumulator,
};
use crate::{
auth_events::AuthEventMetricAccumulator,
errors::{AnalyticsError, AnalyticsResult},
AnalyticsProvider,
};
pub async fn get_metrics(
pool: &AnalyticsProvider,
merchant_id: &common_utils::id_type::MerchantId,
req: GetAuthEventMetricRequest,
) -> AnalyticsResult<AuthEventMetricsResponse<MetricsBucketResponse>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/auth_events/accumulator.rs | crate: analytics
use super::metrics::AuthEventMetricRow;
fn add_metrics_bucket(&mut self, metrics: &AuthEventMetricRow) {
{
(None, None) => None,<|fim_suffix|>
<|fim_middle|>
(Some(a), Some(b)) => Some(a + b),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/auth_events/accumulator.rs | crate: analytics
use api_models::analytics::auth_events::AuthEventMetricsBucketValue;
pub fn collect(self) -> AuthEventMetricsBucketValue {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/auth_events/accumulator.rs | crate: analytics
use super::metrics::AuthEventMetricRow;
fn add_metrics_bucket(&mut self, metrics: &AuthEventMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/core.rs | crate: analytics
#[derive(Debug)]
pub enum TaskType {
MetricTask(
RefundMetrics,
CustomResult<HashSet<(RefundMetricsBucketIdentifier, RefundMetricRow)>, AnalyticsError>,
),
DistributionTask(
RefundDistributions,
CustomResult<Vec<(RefundMetricsBucketIdentifier, RefundDistributionRow)>, AnalyticsError>,
),
}
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetRefundMetricRequest,
) -> AnalyticsResult<RefundsMetricsResponse<RefundMetricsBucketResponse>> {
let mut metrics_accumulator: HashMap<RefundMetricsBucketIdentifier, RefundMetricsAccumulator> =
HashMap::new();
let mut set = tokio::task::JoinSet::new();
for metric_type in req.metrics.iter().cloned() {
let req = req.clone();
let pool = pool.clone();
let task_span = tracing::debug_span!(
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetRefundMetricRequest,
) -> AnalyticsResult<RefundsMetricsResponse<RefundMetricsBucketResponse>> {
{
(s, t) if t > 0 => Some(f64::from(s) * 100.0 / f64::from(t)),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/core.rs | crate: analytics
use api_models::analytics::{
refunds::{
RefundDimensions, RefundDistributions, RefundMetrics, RefundMetricsBucketIdentifier,
RefundMetricsBucketResponse,
},
GetRefundFilterRequest, GetRefundMetricRequest, RefundFilterValue, RefundFiltersResponse,
RefundsAnalyticsMetadata, RefundsMetricsResponse,
};
use common_enums::Currency;
use router_env::{
logger,
tracing::{self, Instrument},
};
use super::{
distribution::RefundDistributionRow,
filters::{get_refund_filter_for_dimension, RefundFilterRow},
metrics::RefundMetricRow,
RefundMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
refunds::{accumulator::RefundDistributionAccumulator, RefundMetricAccumulator},
AnalyticsProvider,
};
pub async fn get_filters(
pool: &AnalyticsProvider,
req: GetRefundFilterRequest,
auth: &AuthInfo,
) -> AnalyticsResult<RefundFiltersResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/core.rs | crate: analytics
use std::collections::{HashMap, HashSet};
use api_models::analytics::{
refunds::{
RefundDimensions, RefundDistributions, RefundMetrics, RefundMetricsBucketIdentifier,
RefundMetricsBucketResponse,
},
GetRefundFilterRequest, GetRefundMetricRequest, RefundFilterValue, RefundFiltersResponse,
RefundsAnalyticsMetadata, RefundsMetricsResponse,
};
use common_enums::Currency;
use currency_conversion::{conversion::convert, types::ExchangeRates};
use router_env::{
logger,
tracing::{self, Instrument},
};
use super::{
distribution::RefundDistributionRow,
filters::{get_refund_filter_for_dimension, RefundFilterRow},
metrics::RefundMetricRow,
RefundMetricsAccumulator,
};
use crate::{
enums::AuthInfo,
errors::{AnalyticsError, AnalyticsResult},
metrics,
refunds::{accumulator::RefundDistributionAccumulator, RefundMetricAccumulator},
AnalyticsProvider,
};
pub async fn get_metrics(
pool: &AnalyticsProvider,
ex_rates: &Option<ExchangeRates>,
auth: &AuthInfo,
req: GetRefundMetricRequest,
) -> AnalyticsResult<RefundsMetricsResponse<RefundMetricsBucketResponse>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/metrics.rs | crate: analytics
use api_models::analytics::{
refunds::{
RefundDimensions, RefundFilters, RefundMetrics, RefundMetricsBucketIdentifier, RefundType,
},
Granularity, TimeRange,
};
use std::collections::HashSet;
use refund_count::RefundCount;
use refund_processed_amount::RefundProcessedAmount;
use refund_success_count::RefundSuccessCount;
use refund_success_rate::RefundSuccessRate;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[RefundDimensions],
auth: &AuthInfo,
filters: &RefundFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(RefundMetricsBucketIdentifier, RefundMetricRow)>> {
{
Self::RefundSuccessRate => {
RefundSuccessRate::default()
.load_metrics(dimensions, auth, filters, granularity, time_range, pool)
.await
}<|fim_suffix|>
<|fim_middle|>
Self::SessionizedRefundErrorMessage => {
sessionized_metrics::RefundErrorMessage
.load_metrics(dimensions, auth, filters, granularity, time_range, pool)
.await
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
use super::{distribution::RefundDistributionRow, metrics::RefundMetricRow};
fn add_metrics_bucket(&mut self, metrics: &RefundMetricRow) {
{
(None, None) => None,<|fim_suffix|>
<|fim_middle|>
(Some(a), Some(b)) => Some(a + b),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
use api_models::analytics::refunds::{
ErrorMessagesResult, ReasonsResult, RefundMetricsBucketValue,
};
pub fn collect(self) -> RefundMetricsBucketValue {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
Some(self.count)
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
let total = u64::try_from(self.total.unwrap_or_default()).ok();
let count = self.count.and_then(|i| u64::try_from(i).ok());
(total, count, Some(0))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
use bigdecimal::ToPrimitive;
use super::{distribution::RefundDistributionRow, metrics::RefundMetricRow};
fn add_metrics_bucket(&mut self, metrics: &RefundMetricRow) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
fn collect(self) -> Self::MetricOutput {
self.count.and_then(|i| u64::try_from(i).ok())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
use super::{distribution::RefundDistributionRow, metrics::RefundMetricRow};
fn add_distribution_bucket(&mut self, distribution: &RefundDistributionRow) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
use api_models::analytics::refunds::{
ErrorMessagesResult, ReasonsResult, RefundMetricsBucketValue,
};
fn collect(mut self) -> Self::DistributionOutput {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/refunds/accumulator.rs | crate: analytics
use super::{distribution::RefundDistributionRow, metrics::RefundMetricRow};
fn add_distribution_bucket(&mut self, distribution: &RefundDistributionRow) {
self.refund_reason_vec.push(RefundReasonDistributionRow {
count: distribution.count.unwrap_or_default(),
total: distribution
.total
.clone()
.map(|i| i.to_i64().unwrap_or_default())
.unwrap_or_default(),
refund_reason: distribution.refund_reason.clone().unwrap_or_default(),
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/metrics/refund_processed_amount.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
refunds::{RefundDimensions, RefundFilters, RefundMetricsBucketIdentifier},
Granularity, TimeRange,
};
use diesel_models::enums as storage_enums;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::RefundMetricRow;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[RefundDimensions],
auth: &AuthInfo,
filters: &RefundFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(RefundMetricsBucketIdentifier, RefundMetricRow)>>
where
T: AnalyticsDataSource + super::RefundMetricAnalytics,
{
{
(Some(g), Some(st)) => g.clip_to_start(st)?,<|fim_suffix|>
<|fim_middle|>
_ => time_range.start_time,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/refunds/metrics/refund_processed_amount.rs | crate: analytics
use std::collections::HashSet;
use api_models::analytics::{
refunds::{RefundDimensions, RefundFilters, RefundMetricsBucketIdentifier},
Granularity, TimeRange,
};
use diesel_models::enums as storage_enums;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::RefundMetricRow;
use crate::{
enums::AuthInfo,
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
async fn load_metrics(
&self,
dimensions: &[RefundDimensions],
auth: &AuthInfo,
filters: &RefundFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(RefundMetricsBucketIdentifier, RefundMetricRow)>>
where
T: AnalyticsDataSource + super::RefundMetricAnalytics,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use masking::{ExposeInterface, Secret};
use crate::{api::ConnectorCommon, errors};
/// fn verify_webhook_source
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
connector_name: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let algorithm = self
.get_webhook_source_verification_algorithm(request)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_name,
connector_webhook_details,
)
.await
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let signature = self
.get_webhook_source_verification_signature(request, &connector_webhook_secrets)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let message = self
.get_webhook_source_verification_message(
request,
merchant_id,
&connector_webhook_secrets,
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
algorithm
.verify_signature(&connector_webhook_secrets.secret, &signature, &message)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_source_verification_merchant_secret
async fn get_webhook_source_verification_merchant_secret(
&self,
merchant_id: &common_utils::id_type::MerchantId,
connector_name: &str,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<api_models::webhooks::ConnectorWebhookSecrets, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.