systemprompt_api/routes/analytics/
events.rs

1use axum::Json;
2use axum::extract::{Extension, State};
3use axum::http::StatusCode;
4use axum::response::IntoResponse;
5use std::sync::Arc;
6
7use systemprompt_analytics::{
8    AnalyticsEventBatchResponse, AnalyticsEventType, AnalyticsEventsRepository,
9    CreateAnalyticsEventBatchInput, CreateAnalyticsEventInput, CreateEngagementEventInput,
10    EngagementOptionalMetrics, EngagementRepository,
11};
12use systemprompt_content::ContentRepository;
13use systemprompt_identifiers::ContentId;
14use systemprompt_models::ContentRouting;
15use systemprompt_models::api::ApiError;
16use systemprompt_models::execution::context::RequestContext;
17
18#[derive(Clone)]
19pub struct AnalyticsState {
20    pub events: Arc<AnalyticsEventsRepository>,
21    pub content: Arc<ContentRepository>,
22    pub engagement: Arc<EngagementRepository>,
23    pub content_routing: Option<Arc<dyn ContentRouting>>,
24}
25
26impl std::fmt::Debug for AnalyticsState {
27    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
28        f.debug_struct("AnalyticsState")
29            .field("content_routing", &self.content_routing.is_some())
30            .finish_non_exhaustive()
31    }
32}
33
34async fn resolve_content_id(
35    content_repo: &ContentRepository,
36    content_routing: Option<&dyn ContentRouting>,
37    page_url: &str,
38    slug: Option<&str>,
39) -> Option<ContentId> {
40    let resolved_slug;
41    let slug_to_use = if let Some(s) = slug {
42        s
43    } else {
44        resolved_slug = content_routing.and_then(|r| r.resolve_slug(page_url))?;
45        &resolved_slug
46    };
47
48    content_repo
49        .get_by_slug(slug_to_use)
50        .await
51        .map_err(|e| {
52            tracing::warn!(error = %e, slug = %slug_to_use, "Failed to lookup content by slug");
53            e
54        })
55        .ok()
56        .flatten()
57        .map(|c| c.id)
58}
59
60pub async fn record_event(
61    State(state): State<AnalyticsState>,
62    Extension(req_ctx): Extension<RequestContext>,
63    Json(mut input): Json<CreateAnalyticsEventInput>,
64) -> Result<impl IntoResponse, ApiError> {
65    if input.content_id.is_none() {
66        input.content_id = resolve_content_id(
67            &state.content,
68            state.content_routing.as_deref(),
69            &input.page_url,
70            input.slug.as_deref(),
71        )
72        .await;
73    }
74
75    let created = state
76        .events
77        .create_event(req_ctx.session_id(), req_ctx.user_id(), &input)
78        .await
79        .map_err(|e| {
80            tracing::error!(error = %e, "Failed to record analytics event");
81            ApiError::internal_error("Failed to record analytics event")
82        })?;
83
84    if input.event_type == AnalyticsEventType::PageExit {
85        fan_out_engagement(&state, &req_ctx, &input).await;
86    }
87
88    Ok((StatusCode::CREATED, Json(created)))
89}
90
91pub async fn record_events_batch(
92    State(state): State<AnalyticsState>,
93    Extension(req_ctx): Extension<RequestContext>,
94    Json(mut input): Json<CreateAnalyticsEventBatchInput>,
95) -> Result<impl IntoResponse, ApiError> {
96    for event in &mut input.events {
97        if event.content_id.is_none() {
98            event.content_id = resolve_content_id(
99                &state.content,
100                state.content_routing.as_deref(),
101                &event.page_url,
102                event.slug.as_deref(),
103            )
104            .await;
105        }
106    }
107
108    let created = state
109        .events
110        .create_events_batch(req_ctx.session_id(), req_ctx.user_id(), &input.events)
111        .await
112        .map_err(|e| {
113            tracing::error!(error = %e, "Failed to record analytics events batch");
114            ApiError::internal_error("Failed to record analytics events")
115        })?;
116
117    for event in &input.events {
118        if event.event_type == AnalyticsEventType::PageExit {
119            fan_out_engagement(&state, &req_ctx, event).await;
120        }
121    }
122
123    Ok((
124        StatusCode::CREATED,
125        Json(AnalyticsEventBatchResponse {
126            recorded: created.len(),
127            events: created,
128        }),
129    ))
130}
131
132async fn fan_out_engagement(
133    state: &AnalyticsState,
134    req_ctx: &RequestContext,
135    input: &CreateAnalyticsEventInput,
136) {
137    let Some(ref data) = input.data else { return };
138
139    let get_i32 = |key: &str| -> Option<i32> {
140        data.get(key)
141            .and_then(serde_json::Value::as_i64)
142            .map(|v| v as i32)
143    };
144    let get_f32 = |key: &str| -> Option<f32> {
145        data.get(key)
146            .and_then(serde_json::Value::as_f64)
147            .map(|v| v as f32)
148    };
149    let get_bool =
150        |key: &str| -> Option<bool> { data.get(key).and_then(serde_json::Value::as_bool) };
151    let get_string =
152        |key: &str| -> Option<String> { data.get(key).and_then(|v| v.as_str()).map(String::from) };
153
154    let time_on_page = get_i32("time_on_page_ms").unwrap_or(0);
155    if time_on_page == 0 {
156        return;
157    }
158
159    let engagement_input = CreateEngagementEventInput {
160        page_url: input.page_url.clone(),
161        event_type: input.event_type.as_str().to_string(),
162        time_on_page_ms: time_on_page,
163        max_scroll_depth: get_i32("max_scroll_depth").unwrap_or(0),
164        click_count: get_i32("click_count").unwrap_or(0),
165        optional_metrics: EngagementOptionalMetrics {
166            time_to_first_interaction_ms: get_i32("time_to_first_interaction_ms"),
167            time_to_first_scroll_ms: get_i32("time_to_first_scroll_ms"),
168            scroll_velocity_avg: get_f32("scroll_velocity_avg"),
169            scroll_direction_changes: get_i32("scroll_direction_changes"),
170            mouse_move_distance_px: get_i32("mouse_move_distance_px"),
171            keyboard_events: get_i32("keyboard_events"),
172            copy_events: get_i32("copy_events"),
173            focus_time_ms: get_i32("focus_time_ms"),
174            blur_count: get_i32("blur_count"),
175            tab_switches: get_i32("tab_switches"),
176            visible_time_ms: get_i32("visible_time_ms"),
177            hidden_time_ms: get_i32("hidden_time_ms"),
178            is_rage_click: get_bool("is_rage_click"),
179            is_dead_click: get_bool("is_dead_click"),
180            reading_pattern: get_string("reading_pattern"),
181        },
182    };
183
184    let content_id = resolve_content_id(
185        &state.content,
186        state.content_routing.as_deref(),
187        &input.page_url,
188        input.slug.as_deref(),
189    )
190    .await;
191
192    if let Err(e) = state
193        .engagement
194        .create_engagement(
195            req_ctx.session_id(),
196            req_ctx.user_id(),
197            content_id.as_ref(),
198            &engagement_input,
199        )
200        .await
201    {
202        tracing::warn!(error = %e, "Failed to fan out engagement data from page_exit event");
203    }
204}
systemprompt_api/routes/analytics/events.rs

systemprompt_api/routes/analytics/
events.rs
