systemprompt_analytics/services/
extractor.rs1use http::{HeaderMap, Uri};
2use std::collections::HashMap;
3
4use axum::extract::Request;
5
6use super::bot_keywords::{matches_bot_ip_range, matches_bot_pattern};
7use super::detection;
8use super::user_agent::parse_user_agent;
9use crate::GeoIpReader;
10
11#[derive(Debug, Clone, Default)]
12pub struct SessionAnalytics {
13 pub ip_address: Option<String>,
14 pub user_agent: Option<String>,
15 pub device_type: Option<String>,
16 pub browser: Option<String>,
17 pub os: Option<String>,
18 pub fingerprint_hash: Option<String>,
19 pub preferred_locale: Option<String>,
20 pub country: Option<String>,
21 pub region: Option<String>,
22 pub city: Option<String>,
23 pub referrer_source: Option<String>,
24 pub referrer_url: Option<String>,
25 pub landing_page: Option<String>,
26 pub entry_url: Option<String>,
27 pub utm_source: Option<String>,
28 pub utm_medium: Option<String>,
29 pub utm_campaign: Option<String>,
30 pub utm_content: Option<String>,
31 pub utm_term: Option<String>,
32}
33
34impl SessionAnalytics {
35 pub fn from_headers(headers: &HeaderMap) -> Self {
36 Self::from_headers_with_geoip(headers, None)
37 }
38
39 pub fn from_headers_with_geoip(
40 headers: &HeaderMap,
41 geoip_reader: Option<&GeoIpReader>,
42 ) -> Self {
43 Self::from_headers_with_geoip_and_socket(headers, geoip_reader, None)
44 }
45
46 pub fn from_headers_with_geoip_and_socket(
47 headers: &HeaderMap,
48 geoip_reader: Option<&GeoIpReader>,
49 socket_addr: Option<std::net::SocketAddr>,
50 ) -> Self {
51 let user_agent = headers
52 .get("user-agent")
53 .and_then(|v| v.to_str().ok())
54 .map(ToString::to_string);
55
56 let ip_address = headers
57 .get("x-forwarded-for")
58 .and_then(|v| v.to_str().ok())
59 .and_then(|s| s.split(',').next())
60 .map(|s| s.trim().to_string())
61 .or_else(|| {
62 headers
63 .get("x-real-ip")
64 .and_then(|v| v.to_str().ok())
65 .map(ToString::to_string)
66 })
67 .or_else(|| socket_addr.map(|addr| addr.ip().to_string()));
68
69 let fingerprint_hash = headers
70 .get("x-fingerprint")
71 .and_then(|v| v.to_str().ok())
72 .map(ToString::to_string);
73
74 let preferred_locale = headers
75 .get("accept-language")
76 .and_then(|v| v.to_str().ok())
77 .and_then(|s| s.split(',').next())
78 .map(|s| s.trim().split(';').next().unwrap_or(s).to_string());
79
80 let (device_type, browser, os) = user_agent
81 .as_ref()
82 .map_or((None, None, None), |ua| parse_user_agent(ua));
83
84 let (country, region, city) = ip_address
85 .as_ref()
86 .and_then(|ip_str| Self::lookup_geoip(ip_str, geoip_reader))
87 .unwrap_or((None, None, None));
88
89 let referrer_url = headers
90 .get("referer")
91 .and_then(|v| v.to_str().ok())
92 .map(ToString::to_string);
93
94 let referrer_source = referrer_url
95 .as_ref()
96 .and_then(|url| Self::parse_referrer_source(url));
97
98 Self {
99 ip_address,
100 user_agent,
101 device_type,
102 browser,
103 os,
104 fingerprint_hash,
105 preferred_locale,
106 country,
107 region,
108 city,
109 referrer_source,
110 referrer_url,
111 landing_page: None,
112 entry_url: None,
113 utm_source: None,
114 utm_medium: None,
115 utm_campaign: None,
116 utm_content: None,
117 utm_term: None,
118 }
119 }
120
121 pub fn from_headers_and_uri(
122 headers: &HeaderMap,
123 uri: Option<&Uri>,
124 geoip_reader: Option<&GeoIpReader>,
125 content_routing: Option<&dyn systemprompt_models::ContentRouting>,
126 ) -> Self {
127 let mut analytics = Self::from_headers_with_geoip(headers, geoip_reader);
128
129 if let Some(uri) = uri {
130 let query_params = Self::parse_query_params(uri);
131
132 analytics.utm_source = query_params.get("utm_source").cloned();
133 analytics.utm_medium = query_params.get("utm_medium").cloned();
134 analytics.utm_campaign = query_params.get("utm_campaign").cloned();
135 analytics.utm_content = query_params.get("utm_content").cloned();
136 analytics.utm_term = query_params.get("utm_term").cloned();
137
138 let is_html_page =
139 content_routing.is_some_and(|routing| routing.is_html_page(uri.path()));
140
141 if is_html_page {
142 analytics.entry_url = Some(uri.to_string());
143 analytics.landing_page = Some(uri.path().to_string());
144 }
145 }
146
147 analytics
148 }
149
150 pub fn from_request(
151 request: &Request,
152 geoip_reader: Option<&GeoIpReader>,
153 content_routing: Option<&dyn systemprompt_models::ContentRouting>,
154 ) -> Self {
155 Self::from_headers_and_uri(
156 request.headers(),
157 Some(request.uri()),
158 geoip_reader,
159 content_routing,
160 )
161 }
162
163 fn parse_query_params(uri: &Uri) -> HashMap<String, String> {
164 uri.query().map_or_else(HashMap::new, |q| {
165 q.split('&')
166 .filter_map(|param| {
167 let mut parts = param.splitn(2, '=');
168 Some((parts.next()?.to_string(), parts.next()?.to_string()))
169 })
170 .collect()
171 })
172 }
173
174 #[cfg(feature = "geolocation")]
175 fn lookup_geoip(
176 ip_str: &str,
177 geoip_reader: Option<&GeoIpReader>,
178 ) -> Option<(Option<String>, Option<String>, Option<String>)> {
179 let Some(reader) = geoip_reader else {
180 tracing::debug!(ip = %ip_str, "GeoIP lookup skipped: reader not configured");
181 return None;
182 };
183
184 let ip: std::net::IpAddr = match ip_str.parse() {
185 Ok(ip) => ip,
186 Err(e) => {
187 tracing::debug!(ip = %ip_str, error = %e, "GeoIP lookup failed: invalid IP address");
188 return None;
189 },
190 };
191
192 if ip.is_loopback() || ip.is_unspecified() {
193 tracing::debug!(ip = %ip_str, "GeoIP lookup skipped: loopback or unspecified address");
194 return None;
195 }
196
197 if let std::net::IpAddr::V4(ipv4) = ip {
198 if ipv4.is_private() || ipv4.is_link_local() {
199 tracing::debug!(ip = %ip_str, "GeoIP lookup skipped: private or link-local address");
200 return None;
201 }
202 }
203
204 let lookup_result = match reader.lookup(ip) {
205 Ok(result) => result,
206 Err(e) => {
207 tracing::debug!(ip = %ip_str, error = %e, "GeoIP lookup failed: database lookup error");
208 return None;
209 },
210 };
211
212 let city_data: maxminddb::geoip2::City = match lookup_result.decode() {
213 Ok(Some(data)) => data,
214 Ok(None) => {
215 tracing::debug!(ip = %ip_str, "GeoIP lookup returned empty result");
216 return None;
217 },
218 Err(e) => {
219 tracing::debug!(ip = %ip_str, error = %e, "GeoIP decode failed");
220 return None;
221 },
222 };
223
224 let country = city_data.country.iso_code.map(ToString::to_string);
225
226 let region = city_data
227 .subdivisions
228 .first()
229 .and_then(|s| s.iso_code)
230 .map(ToString::to_string);
231
232 let city_name = city_data.city.names.english.map(ToString::to_string);
233
234 Some((country, region, city_name))
235 }
236
237 #[cfg(not(feature = "geolocation"))]
238 const fn lookup_geoip(
239 _ip_str: &str,
240 _geoip_reader: Option<&GeoIpReader>,
241 ) -> Option<(Option<String>, Option<String>, Option<String>)> {
242 None
243 }
244
245 fn parse_referrer_source(url: &str) -> Option<String> {
246 url::Url::parse(url)
247 .ok()
248 .and_then(|parsed_url| parsed_url.host_str().map(ToString::to_string))
249 .filter(|host| host.parse::<std::net::IpAddr>().is_err())
250 }
251
252 pub fn is_bot(&self) -> bool {
253 self.user_agent
254 .as_ref()
255 .is_none_or(|ua| ua.is_empty() || matches_bot_pattern(ua))
256 }
257
258 pub fn is_bot_ip(&self) -> bool {
259 self.ip_address
260 .as_ref()
261 .is_some_and(|ip| matches_bot_ip_range(ip))
262 }
263
264 pub fn is_spam_referrer(&self) -> bool {
265 self.referrer_url
266 .as_ref()
267 .is_some_and(|url| detection::is_spam_referrer(url))
268 }
269
270 pub fn is_datacenter_ip(&self) -> bool {
271 self.ip_address
272 .as_ref()
273 .is_some_and(|ip| detection::is_datacenter_ip(ip))
274 }
275
276 pub fn is_high_risk_country(&self) -> bool {
277 self.country
278 .as_ref()
279 .is_some_and(|c| detection::is_high_risk_country(c))
280 }
281
282 pub fn should_skip_tracking(&self) -> bool {
283 self.is_bot()
284 || self.is_bot_ip()
285 || self.is_datacenter_ip()
286 || self.is_high_risk_country()
287 || self.is_spam_referrer()
288 }
289}