345 lines
17 KiB
Go
345 lines
17 KiB
Go
package analytics
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"slices"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
type Period struct {
|
|
PeriodID string `json:"periodId"`
|
|
PeriodType string `json:"periodType"`
|
|
StartAt time.Time `json:"startAt"`
|
|
EndAt time.Time `json:"endAt"`
|
|
LocalStartAt time.Time `json:"localStartAt"`
|
|
LocalEndAt time.Time `json:"localEndAt"`
|
|
Timezone string `json:"timezone"`
|
|
JalaliLabelFA string `json:"jalaliLabelFa"`
|
|
IsComplete bool `json:"isComplete"`
|
|
IsDefault bool `json:"isDefault"`
|
|
}
|
|
|
|
type Run struct {
|
|
RunID string `json:"runId"`
|
|
State string `json:"state"`
|
|
Period Period `json:"period"`
|
|
DatasetSnapshotID string `json:"datasetSnapshotId"`
|
|
MetricDefinitionVersion string `json:"metricDefinitionVersion"`
|
|
CreatedAt time.Time `json:"createdAt"`
|
|
UpdatedAt time.Time `json:"updatedAt"`
|
|
EventsURL string `json:"eventsUrl"`
|
|
Scope RunScope `json:"scope"`
|
|
Sections map[string]any `json:"sections"`
|
|
}
|
|
|
|
type RunScope struct {
|
|
TerminalID *string `json:"terminalId"`
|
|
}
|
|
|
|
type PaymentHistoryPoint struct {
|
|
LocalDate string `json:"localDate"`
|
|
TotalSessions int64 `json:"totalSessions"`
|
|
BankPaidSessions int64 `json:"bankPaidSessions"`
|
|
BankPaidAmountRial int64 `json:"bankPaidAmountRial"`
|
|
}
|
|
|
|
type Service struct {
|
|
pool *pgxpool.Pool
|
|
cursorSecret []byte
|
|
mu sync.RWMutex
|
|
runs map[string]storedRun
|
|
}
|
|
|
|
type storedRun struct {
|
|
merchantID int64
|
|
run Run
|
|
}
|
|
|
|
func New(pool *pgxpool.Pool, cursorSecret string) *Service {
|
|
return &Service{pool: pool, cursorSecret: []byte(cursorSecret), runs: map[string]storedRun{}}
|
|
}
|
|
|
|
func (s *Service) Periods(ctx context.Context) ([]Period, error) {
|
|
var start, end time.Time
|
|
err := s.pool.QueryRow(ctx, `SELECT min(created_at),max(created_at) FROM payment_sessions`).Scan(&start, &end)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("loading dataset period: %w", err)
|
|
}
|
|
location, err := time.LoadLocation("Asia/Tehran")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("loading tehran timezone: %w", err)
|
|
}
|
|
return completePeriods(start, end, location), nil
|
|
}
|
|
|
|
func (s *Service) Start(ctx context.Context, merchantID int64, period Period, terminalID string) (Run, error) {
|
|
if err := s.validateTerminal(ctx, merchantID, terminalID); err != nil {
|
|
return Run{}, err
|
|
}
|
|
key := fmt.Sprintf("%d:%s:%s", merchantID, period.PeriodID, terminalID)
|
|
s.mu.RLock()
|
|
existing, ok := s.runs[key]
|
|
s.mu.RUnlock()
|
|
if ok {
|
|
return existing.run, nil
|
|
}
|
|
now := time.Now().UTC()
|
|
run := Run{RunID: fmt.Sprintf("run_%d%d", merchantID, now.UnixNano()), State: "COMPLETE", Period: period,
|
|
DatasetSnapshotID: "ds_localimport", MetricDefinitionVersion: "0.4.0", CreatedAt: now, UpdatedAt: now,
|
|
Sections: map[string]any{}}
|
|
if terminalID != "" {
|
|
run.Scope.TerminalID = &terminalID
|
|
}
|
|
run.EventsURL = "/api/v1/analytics/runs/" + run.RunID + "/events"
|
|
metrics, err := s.metrics(ctx, merchantID, period, terminalID)
|
|
if err != nil {
|
|
return Run{}, err
|
|
}
|
|
history, err := s.paymentHistory(ctx, merchantID, period, terminalID)
|
|
if err != nil {
|
|
return Run{}, err
|
|
}
|
|
metadata := map[string]any{"calculatedAt": now, "datasetSnapshotId": run.DatasetSnapshotID, "metricDefinitionVersion": "0.4.0"}
|
|
run.Sections["overview"] = map[string]any{"sectionId": "overview", "state": "READY", "metadata": metadata, "data": metrics.overview(period, history)}
|
|
run.Sections["paymentPerformance"] = map[string]any{"sectionId": "payment_performance", "state": "READY", "metadata": metadata, "data": metrics.performance()}
|
|
run.Sections["fees"] = map[string]any{"sectionId": "fees", "state": "READY", "metadata": metadata, "data": metrics.fees(period)}
|
|
if !peerComparisonSupported(terminalID) {
|
|
run.Sections["peerComparison"] = map[string]any{"sectionId": "peer_comparison", "state": "SUPPRESSED", "metadata": metadata,
|
|
"reason": "TERMINAL_SCOPE_UNSUPPORTED", "eligiblePeerCount": 0, "combinedPeerSessionCount": 0,
|
|
"requiredPeerCount": 10, "requiredPeerSessionCount": 1000}
|
|
} else {
|
|
peerCount, peerSessions, err := s.peerEligibility(ctx, merchantID, period)
|
|
if err != nil {
|
|
return Run{}, err
|
|
}
|
|
if peerCount < 10 || peerSessions < 1000 {
|
|
run.Sections["peerComparison"] = map[string]any{"sectionId": "peer_comparison", "state": "SUPPRESSED", "metadata": metadata,
|
|
"reason": "INSUFFICIENT_COHORT", "eligiblePeerCount": peerCount, "combinedPeerSessionCount": peerSessions,
|
|
"requiredPeerCount": 10, "requiredPeerSessionCount": 1000}
|
|
} else {
|
|
peerMetrics, err := s.peerMetrics(ctx, merchantID, period)
|
|
if err != nil {
|
|
return Run{}, err
|
|
}
|
|
run.Sections["peerComparison"] = map[string]any{"sectionId": "peer_comparison", "state": "READY", "metadata": metadata,
|
|
"data": map[string]any{"eligiblePeerCount": peerCount, "combinedPeerSessionCount": peerSessions, "metrics": peerMetrics}}
|
|
}
|
|
}
|
|
s.mu.Lock()
|
|
s.runs[key] = storedRun{merchantID: merchantID, run: run}
|
|
s.runs[run.RunID] = storedRun{merchantID: merchantID, run: run}
|
|
s.mu.Unlock()
|
|
return run, nil
|
|
}
|
|
|
|
func peerComparisonSupported(terminalID string) bool { return terminalID == "" }
|
|
|
|
func (s *Service) Run(merchantID int64, runID string) (Run, bool) {
|
|
s.mu.RLock()
|
|
stored, ok := s.runs[runID]
|
|
s.mu.RUnlock()
|
|
return stored.run, ok && stored.merchantID == merchantID
|
|
}
|
|
|
|
type metricValues struct {
|
|
total, paid, verified, unverified, failed, reversed, noAttempt, reachedBank, retried, recovered int64
|
|
paidAmount, feeAmount int64
|
|
initP50, initP95, verifyP50, verifyP95 *float64
|
|
initSamples, verifySamples int64
|
|
}
|
|
|
|
func (s *Service) metrics(ctx context.Context, merchantID int64, p Period, terminalID string) (metricValues, error) {
|
|
var m metricValues
|
|
query := `WITH scoped AS (
|
|
SELECT ps.*,count(pa.id) attempts,bool_or(pa.status='InBank') reached_bank
|
|
FROM payment_sessions ps LEFT JOIN payment_attempts pa ON pa.session_id=ps.id
|
|
WHERE ps.merchant_id=$1 AND ps.created_at >= $2 AND ps.created_at < $3
|
|
AND ($4='' OR ps.terminal_id=(SELECT id FROM terminals WHERE merchant_id=$1 AND source_key=$4)) GROUP BY ps.id
|
|
), timings AS (
|
|
SELECT percentile_disc(0.5) within group(order by pa.init_time_ms)::float8 init_p50,
|
|
percentile_disc(0.95) within group(order by pa.init_time_ms)::float8 init_p95,
|
|
percentile_disc(0.5) within group(order by pa.verify_time_ms)::float8 verify_p50,
|
|
percentile_disc(0.95) within group(order by pa.verify_time_ms)::float8 verify_p95,
|
|
count(pa.init_time_ms) init_samples,count(pa.verify_time_ms) verify_samples
|
|
FROM payment_attempts pa JOIN payment_sessions ps ON ps.id=pa.session_id
|
|
WHERE ps.merchant_id=$1 AND ps.created_at >= $2 AND ps.created_at < $3
|
|
AND ($4='' OR ps.terminal_id=(SELECT id FROM terminals WHERE merchant_id=$1 AND source_key=$4)))
|
|
SELECT count(*),count(*) filter(where status in ('Paid','Verified')),
|
|
count(*) filter(where status='Verified'),count(*) filter(where status='Paid'),count(*) filter(where status='Failed'),
|
|
count(*) filter(where status='Reversed'),count(*) filter(where attempts=0),count(*) filter(where reached_bank),
|
|
count(*) filter(where attempts>1),count(*) filter(where attempts>1 and status in ('Paid','Verified')),
|
|
coalesce(sum(amount_rial) filter(where status in ('Paid','Verified')),0),coalesce(sum(fee_amount_rial) filter(where status in ('Paid','Verified')),0),
|
|
t.init_p50,t.init_p95,t.verify_p50,t.verify_p95,t.init_samples,t.verify_samples
|
|
FROM scoped CROSS JOIN timings t GROUP BY t.init_p50,t.init_p95,t.verify_p50,t.verify_p95,t.init_samples,t.verify_samples`
|
|
err := s.pool.QueryRow(ctx, query, merchantID, p.StartAt, p.EndAt, terminalID).Scan(&m.total, &m.paid, &m.verified, &m.unverified,
|
|
&m.failed, &m.reversed, &m.noAttempt, &m.reachedBank, &m.retried, &m.recovered, &m.paidAmount,
|
|
&m.feeAmount, &m.initP50, &m.initP95, &m.verifyP50, &m.verifyP95, &m.initSamples, &m.verifySamples)
|
|
if err != nil {
|
|
return metricValues{}, fmt.Errorf("calculating merchant metrics: %w", err)
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func integerMetric(id string, value int64, unit string) map[string]any {
|
|
return map[string]any{"metricId": id, "value": value, "unit": unit}
|
|
}
|
|
func decimalMetric(id string, numerator, denominator int64, unit string) map[string]any {
|
|
var value any
|
|
if denominator > 0 {
|
|
value = fmt.Sprintf("%.2f", float64(numerator)*100/float64(denominator))
|
|
}
|
|
return map[string]any{"metricId": id, "value": value, "unit": unit, "numerator": numerator, "denominator": denominator}
|
|
}
|
|
func unavailableComparison(period Period) map[string]any {
|
|
return map[string]any{"state": "UNAVAILABLE", "baselinePeriod": period, "absoluteChange": nil, "relativeChangePercent": nil, "unavailableReason": "SOURCE_UNAVAILABLE", "isActionableInsightEligible": false}
|
|
}
|
|
|
|
func (m metricValues) overview(period Period, history []PaymentHistoryPoint) map[string]any {
|
|
return map[string]any{
|
|
"bankPaidSessions": integerMetric("bank_paid_sessions", m.paid, "SESSIONS"), "bankPaidAmountRial": integerMetric("bank_paid_amount_rial", m.paidAmount, "RIAL"),
|
|
"paymentSuccessRate": decimalMetric("payment_success_rate", m.paid, m.total, "PERCENT"), "verificationCompletionRate": decimalMetric("verification_completion_rate", m.verified, m.paid, "PERCENT"),
|
|
"comparisons": map[string]any{"bank_paid_sessions": unavailableComparison(period), "bank_paid_amount_rial": unavailableComparison(period), "payment_success_rate": unavailableComparison(period), "verification_completion_rate": unavailableComparison(period)},
|
|
"paymentHistory": history,
|
|
}
|
|
}
|
|
|
|
func (s *Service) paymentHistory(ctx context.Context, merchantID int64, period Period, terminalID string) ([]PaymentHistoryPoint, error) {
|
|
rows, err := s.pool.Query(ctx, `SELECT (ps.created_at AT TIME ZONE 'Asia/Tehran')::date local_date,
|
|
count(*),count(*) FILTER (WHERE ps.status IN ('Paid','Verified')),
|
|
coalesce(sum(ps.amount_rial) FILTER (WHERE ps.status IN ('Paid','Verified')),0)
|
|
FROM payment_sessions ps WHERE ps.merchant_id=$1 AND ps.created_at >= $2 AND ps.created_at < $3
|
|
AND ($4='' OR ps.terminal_id=(SELECT id FROM terminals WHERE merchant_id=$1 AND source_key=$4))
|
|
GROUP BY local_date ORDER BY local_date`, merchantID, period.StartAt, period.EndAt, terminalID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("querying payment history: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
points := make([]PaymentHistoryPoint, 0, 93)
|
|
for rows.Next() {
|
|
var date time.Time
|
|
var point PaymentHistoryPoint
|
|
if err := rows.Scan(&date, &point.TotalSessions, &point.BankPaidSessions, &point.BankPaidAmountRial); err != nil {
|
|
return nil, fmt.Errorf("scanning payment history: %w", err)
|
|
}
|
|
point.LocalDate = date.Format(time.DateOnly)
|
|
points = append(points, point)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, fmt.Errorf("iterating payment history: %w", err)
|
|
}
|
|
return points, nil
|
|
}
|
|
func timing(id string, p50, p95 *float64, samples, eligible int64) map[string]any {
|
|
var a, b any
|
|
if p50 != nil {
|
|
a = int64(math.Round(*p50))
|
|
}
|
|
if p95 != nil {
|
|
b = int64(math.Round(*p95))
|
|
}
|
|
var coverage any
|
|
if eligible > 0 {
|
|
coverage = fmt.Sprintf("%.2f", float64(samples)*100/float64(eligible))
|
|
}
|
|
return map[string]any{"metricId": id, "p50Ms": a, "p95Ms": b, "sampleSize": samples, "eligibleSampleSize": eligible, "coveragePercent": coverage}
|
|
}
|
|
func (m metricValues) performance() map[string]any {
|
|
return map[string]any{
|
|
"bankPaidSessions": integerMetric("bank_paid_sessions", m.paid, "SESSIONS"), "verifiedSessions": integerMetric("verified_sessions", m.verified, "SESSIONS"), "unverifiedPaidSessions": integerMetric("unverified_paid_sessions", m.unverified, "SESSIONS"),
|
|
"failedSessions": integerMetric("failed_sessions", m.failed, "SESSIONS"), "reversedSessions": integerMetric("reversed_sessions", m.reversed, "SESSIONS"), "noAttemptSessions": integerMetric("no_attempt_sessions", m.noAttempt, "SESSIONS"),
|
|
"reachedBankSessions": integerMetric("reached_bank_sessions", m.reachedBank, "SESSIONS"), "retriedSessions": integerMetric("retried_sessions", m.retried, "SESSIONS"), "retryRecoveryRate": decimalMetric("retry_recovery_rate", m.recovered, m.retried, "PERCENT"),
|
|
"initTiming": timing("init_time_ms", m.initP50, m.initP95, m.initSamples, m.total), "verifyTiming": timing("verify_time_ms", m.verifyP50, m.verifyP95, m.verifySamples, m.paid),
|
|
}
|
|
}
|
|
func (m metricValues) fees(period Period) map[string]any {
|
|
return map[string]any{"paidFeeAmountRial": integerMetric("paid_fee_amount_rial", m.feeAmount, "RIAL"), "bankPaidAmountRial": integerMetric("bank_paid_amount_rial", m.paidAmount, "RIAL"), "paidFeeRate": decimalMetric("paid_fee_rate", m.feeAmount, m.paidAmount, "RATIO"), "comparison": unavailableComparison(period)}
|
|
}
|
|
|
|
func (s *Service) peerEligibility(ctx context.Context, merchantID int64, p Period) (int64, int64, error) {
|
|
var peers, sessions int64
|
|
err := s.pool.QueryRow(ctx, `SELECT count(distinct ps.merchant_id),count(*) FROM payment_sessions ps JOIN merchants m ON m.id=ps.merchant_id
|
|
WHERE m.category_id=(SELECT category_id FROM merchants WHERE id=$1) AND ps.merchant_id<>$1 AND ps.created_at>=$2 AND ps.created_at<$3`, merchantID, p.StartAt, p.EndAt).Scan(&peers, &sessions)
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("calculating peer eligibility: %w", err)
|
|
}
|
|
return peers, sessions, nil
|
|
}
|
|
|
|
type peerRow struct {
|
|
merchantID int64
|
|
values [8]*float64
|
|
}
|
|
|
|
func (s *Service) peerMetrics(ctx context.Context, merchantID int64, p Period) ([]map[string]any, error) {
|
|
query := `WITH session_stats AS (SELECT ps.merchant_id,ps.id,ps.status,ps.amount_rial,ps.fee_amount_rial,count(pa.id) attempts
|
|
FROM payment_sessions ps LEFT JOIN payment_attempts pa ON pa.session_id=ps.id JOIN merchants m ON m.id=ps.merchant_id
|
|
WHERE m.category_id=(SELECT category_id FROM merchants WHERE id=$1) AND ps.created_at>=$2 AND ps.created_at<$3 GROUP BY ps.id),
|
|
aggregate AS (SELECT merchant_id,100.0*count(*) filter(where status in ('Paid','Verified'))/nullif(count(*),0) success,
|
|
100.0*count(*) filter(where status='Verified')/nullif(count(*) filter(where status in ('Paid','Verified')),0) verification,
|
|
100.0*count(*) filter(where attempts>1 and status in ('Paid','Verified'))/nullif(count(*) filter(where attempts>1),0) recovery,
|
|
100.0*sum(fee_amount_rial) filter(where status in ('Paid','Verified'))/nullif(sum(amount_rial) filter(where status in ('Paid','Verified')),0) fee FROM session_stats GROUP BY merchant_id),
|
|
timing AS (SELECT ps.merchant_id,percentile_disc(.5) within group(order by pa.init_time_ms)::float8 ip50,percentile_disc(.95) within group(order by pa.init_time_ms)::float8 ip95,
|
|
percentile_disc(.5) within group(order by pa.verify_time_ms)::float8 vp50,percentile_disc(.95) within group(order by pa.verify_time_ms)::float8 vp95
|
|
FROM payment_sessions ps JOIN payment_attempts pa ON pa.session_id=ps.id JOIN merchants m ON m.id=ps.merchant_id WHERE m.category_id=(SELECT category_id FROM merchants WHERE id=$1) AND ps.created_at>=$2 AND ps.created_at<$3 GROUP BY ps.merchant_id)
|
|
SELECT a.merchant_id,a.success::float8,a.verification::float8,a.recovery::float8,t.ip50,t.ip95,t.vp50,t.vp95,a.fee::float8 FROM aggregate a JOIN timing t USING(merchant_id)`
|
|
rows, err := s.pool.Query(ctx, query, merchantID, p.StartAt, p.EndAt)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("calculating peer metrics: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
all := []peerRow{}
|
|
for rows.Next() {
|
|
var row peerRow
|
|
if err := rows.Scan(&row.merchantID, &row.values[0], &row.values[1], &row.values[2], &row.values[3], &row.values[4], &row.values[5], &row.values[6], &row.values[7]); err != nil {
|
|
return nil, fmt.Errorf("scanning peer metrics: %w", err)
|
|
}
|
|
all = append(all, row)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, fmt.Errorf("iterating peer metrics: %w", err)
|
|
}
|
|
ids := []string{"payment_success_rate", "verification_completion_rate", "retry_recovery_rate", "init_time_ms_p50", "init_time_ms_p95", "verify_time_ms_p50", "verify_time_ms_p95", "paid_fee_rate"}
|
|
metrics := make([]map[string]any, 0, 8)
|
|
for index, id := range ids {
|
|
active := 0.0
|
|
peers := []float64{}
|
|
for _, row := range all {
|
|
if row.values[index] == nil {
|
|
continue
|
|
}
|
|
if row.merchantID == merchantID {
|
|
active = *row.values[index]
|
|
} else {
|
|
peers = append(peers, *row.values[index])
|
|
}
|
|
}
|
|
if len(peers) == 0 {
|
|
peers = append(peers, 0)
|
|
}
|
|
slices.Sort(peers)
|
|
median := peers[len(peers)/2]
|
|
if len(peers)%2 == 0 {
|
|
median = (peers[len(peers)/2-1] + median) / 2
|
|
}
|
|
lowerIsBetter := index >= 3
|
|
better := 0
|
|
for _, value := range peers {
|
|
if (!lowerIsBetter && active >= value) || (lowerIsBetter && active <= value) {
|
|
better++
|
|
}
|
|
}
|
|
percentile := float64(better) * 100 / float64(len(peers))
|
|
direction := "HIGHER_IS_BETTER"
|
|
if lowerIsBetter {
|
|
direction = "LOWER_IS_BETTER"
|
|
}
|
|
metrics = append(metrics, map[string]any{"metricId": id, "cohortMedian": fmt.Sprintf("%.2f", median), "merchantPerformancePercentile": fmt.Sprintf("%.2f", percentile), "direction": direction})
|
|
}
|
|
return metrics, nil
|
|
}
|