:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
use crate::{
api::types::{SessionRecordingConfig, SessionRecordingField},
team::team_models::Team,
};
use axum::http::HeaderMap;
use regex;
use serde_json::{json, Value};
const AUTHORIZED_MOBILE_AND_DESKTOP_CLIENTS: &[&str] = &[
"posthog-android",
"posthog-ios",
"posthog-react-native",
"posthog-flutter",
"posthog-unity",
];
// Hard-coded values set for the session recording beta, still haven't come up with more sensible
// defaults so these are what they are for now.
const SAMPLE_RATE_FULL: &str = "1.00";
const CANVAS_FPS_DEFAULT: u8 = 3;
const CANVAS_QUALITY_DEFAULT: &str = "0.4";
pub fn session_recording_config_response(
team: &Team,
headers: &HeaderMap,
) -> Option<SessionRecordingField> {
if !team.session_recording_opt_in || session_recording_domain_not_allowed(team, headers) {
return Some(SessionRecordingField::Disabled(false));
}
let capture_console_logs = team.capture_console_log_opt_in.unwrap_or(false);
let sample_rate = team.session_recording_sample_rate.as_ref().and_then(|sr| {
let sr_str = sr.to_string();
if sr_str == SAMPLE_RATE_FULL {
None
} else {
Some(sr_str)
}
});
let minimum_duration = team.session_recording_minimum_duration_milliseconds;
let linked_flag = get_linked_flag_value(
team.session_recording_linked_flag
.clone()
.map(|mut v| v.take()),
);
let rrweb_script_config = team
.extra_settings
.as_ref()
.and_then(|cfg| cfg.get("recorder_script"))
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(|script| serde_json::json!({"script": script}));
// session_replay_config logic - only include canvas fields if record_canvas is configured
let (record_canvas, canvas_fps, canvas_quality) = if let Some(cfg) = &team.session_replay_config
{
if let Some(record_canvas) = cfg.get("record_canvas") {
let record_canvas_bool = record_canvas.as_bool().unwrap_or(false);
let fps = if record_canvas_bool {
Some(CANVAS_FPS_DEFAULT)
} else {
None
};
let quality = if record_canvas_bool {
Some(CANVAS_QUALITY_DEFAULT.to_string())
} else {
None
};
(Some(record_canvas_bool), fps, quality)
} else {
(None, None, None)
}
} else {
(None, None, None)
};
let config = SessionRecordingConfig {
endpoint: Some("/s/".to_string()),
console_log_recording_enabled: Some(capture_console_logs),
recorder_version: Some("v2".to_string()),
sample_rate,
minimum_duration_milliseconds: minimum_duration,
linked_flag,
network_payload_capture: team
.session_recording_network_payload_capture_config
.as_ref()
.map(|j| j.0.clone()),
masking: team
.session_recording_masking_config
.as_ref()
.map(|j| j.0.clone()),
url_triggers: team
.session_recording_url_trigger_config
.as_ref()
.map(|vec| Value::Array(vec.iter().map(|j| j.0.clone()).collect())),
url_blocklist: team
.session_recording_url_blocklist_config
.as_ref()
.map(|vec| Value::Array(vec.iter().map(|j| j.0.clone()).collect())),
event_triggers: team
.session_recording_event_trigger_config
.as_ref()
.map(|vec| {
Value::Array(
vec.iter()
.filter_map(|s| s.as_ref().map(|s| Value::String(s.clone())))
.collect(),
)
}),
trigger_match_type: team
.session_recording_trigger_match_type_config
.as_ref()
.map(|s| Value::String(s.clone())),
script_config: rrweb_script_config,
record_canvas,
canvas_fps,
canvas_quality,
};
Some(SessionRecordingField::Config(Box::new(config)))
}
fn session_recording_domain_not_allowed(team: &Team, headers: &HeaderMap) -> bool {
matches!(&team.recording_domains, Some(domains) if !domains.is_empty() && !on_permitted_domain(domains, headers))
}
fn hostname_in_allowed_url_list(allowed: &[String], hostname: Option<&str>) -> bool {
let hostname = match hostname {
Some(h) => h,
None => return false,
};
let permitted_domains: Vec<String> = allowed
.iter()
.filter_map(|url| parse_domain(Some(url)))
.collect();
for permitted_domain in permitted_domains {
if permitted_domain.contains('*') {
// crude wildcard: treat '*' as regex '.*'
let pattern = format!(
"^{}$",
regex::escape(&permitted_domain).replace("\\*", ".*")
);
if regex::Regex::new(&pattern).is_ok_and(|re| re.is_match(hostname)) {
return true;
}
} else if permitted_domain == hostname {
return true;
}
}
false
}
fn get_linked_flag_value(linked_flag_config: Option<Value>) -> Option<Value> {
match &linked_flag_config {
Some(cfg) => {
let key = cfg.get("key");
let variant = cfg.get("variant");
match (key, variant) {
(Some(Value::String(k)), Some(Value::String(v))) => {
Some(json!({"flag": k, "variant": v}))
}
(Some(Value::String(k)), None | Some(Value::Null)) => {
Some(Value::String(k.clone()))
}
_ => None,
}
}
None => None,
}
}
// TODO: this silently drops wildcard domains like `https://*.example.com` because
// url::Url::parse rejects `*` per the WHATWG spec. Django's urlparse is lenient.
// See hypercache-server/src/sanitize.rs for the fixed version.
fn parse_domain(url: Option<&str>) -> Option<String> {
url.and_then(|u| {
if let Ok(parsed) = url::Url::parse(u) {
parsed.host_str().map(|h| h.to_string())
} else {
None
}
})
}
/// Checks if the request originates from a permitted recording domain.
///
/// Returns true if:
/// - Origin or Referer hostname matches one of the allowed domains (supports wildcards)
/// - User-Agent indicates an authorized mobile or desktop client
pub fn on_permitted_domain(recording_domains: &[String], headers: &HeaderMap) -> bool {
let origin = headers.get("Origin").and_then(|v| v.to_str().ok());
let referer = headers.get("Referer").and_then(|v| v.to_str().ok());
let user_agent = headers.get("User-Agent").and_then(|v| v.to_str().ok());
// Parse the domain from the Origin and Referer headers
let origin_hostname = parse_domain(origin);
let referer_hostname = parse_domain(referer);
let is_authorized_web_client =
hostname_in_allowed_url_list(recording_domains, origin_hostname.as_deref())
|| hostname_in_allowed_url_list(recording_domains, referer_hostname.as_deref());
let is_authorized_mobile_or_desktop_client = user_agent.is_some_and(|ua| {
AUTHORIZED_MOBILE_AND_DESKTOP_CLIENTS
.iter()
.any(|&kw| ua.contains(kw))
});
is_authorized_web_client || is_authorized_mobile_or_desktop_client
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn test_get_linked_flag_value_with_null_variant() {
let config = json!({
"id": 105969,
"key": "record_sessions",
"variant": null
});
let result = get_linked_flag_value(Some(config));
assert_eq!(result, Some(Value::String("record_sessions".to_string())));
}
#[test]
fn test_session_recording_domain_allowed_with_empty_domains() {
use axum::http::HeaderMap;
let team = Team {
recording_domains: Some(vec![]),
..Team::default()
};
let headers = HeaderMap::new();
// Empty domains list should allow recording (return false)
assert!(!session_recording_domain_not_allowed(&team, &headers));
}
#[test]
fn test_parse_domain() {
// Test with full URLs - should extract hostname
assert_eq!(
parse_domain(Some("https://app.example.com")),
Some("app.example.com".to_string())
);
assert_eq!(
parse_domain(Some("https://app.example.com/")),
Some("app.example.com".to_string())
);
assert_eq!(
parse_domain(Some("http://localhost:3000")),
Some("localhost".to_string())
);
assert_eq!(
parse_domain(Some("https://app.example.com/path")),
Some("app.example.com".to_string())
);
// Test with bare domains
assert_eq!(parse_domain(Some("app.example.com")), None);
assert_eq!(parse_domain(Some("example.com")), None);
// Test with wildcard domains
assert_eq!(
parse_domain(Some("https://*.example.com")),
Some("*.example.com".to_string())
);
assert_eq!(parse_domain(Some("*.example.com")), None);
// Test with empty string and None
assert_eq!(parse_domain(Some("")), None);
assert_eq!(parse_domain(None), None);
}
#[test]
fn test_on_permitted_domain_with_origin() {
use axum::http::HeaderMap;
let recording_domains = vec!["https://app.example.com/".to_string()];
// Test with Origin header (without trailing slash)
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://app.example.com".parse().unwrap());
assert!(on_permitted_domain(&recording_domains, &headers));
// Test with Origin header (with trailing slash)
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://app.example.com/".parse().unwrap());
assert!(on_permitted_domain(&recording_domains, &headers));
// Test with correct domain with path
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://app.example.com/path".parse().unwrap());
assert!(on_permitted_domain(&recording_domains, &headers));
// Test with wrong domain
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://wrong.example.com".parse().unwrap());
assert!(!on_permitted_domain(&recording_domains, &headers));
}
#[test]
fn test_on_permitted_domain_with_referer() {
use axum::http::HeaderMap;
let recording_domains = vec!["https://app.example.com".to_string()];
// Test with Referer header
let mut headers = HeaderMap::new();
headers.insert(
"Referer",
"https://app.example.com/some/path".parse().unwrap(),
);
assert!(on_permitted_domain(&recording_domains, &headers));
// Test with wrong domain
let mut headers = HeaderMap::new();
headers.insert("Referer", "https://wrong.example.com/path".parse().unwrap());
assert!(!on_permitted_domain(&recording_domains, &headers));
}
#[test]
fn test_on_permitted_domain_with_unity_user_agent() {
use axum::http::HeaderMap;
let recording_domains = vec!["https://web-only.com".to_string()];
let mut headers = HeaderMap::new();
headers.insert("User-Agent", "posthog-unity/1.0.0".parse().unwrap());
assert!(on_permitted_domain(&recording_domains, &headers));
}
#[test]
fn test_on_permitted_domain_with_wildcards() {
use axum::http::HeaderMap;
let recording_domains = vec!["https://*.example.com".to_string()];
// Test with matching subdomain
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://app.example.com".parse().unwrap());
assert!(on_permitted_domain(&recording_domains, &headers));
// Test with different subdomain
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://test.example.com".parse().unwrap());
assert!(on_permitted_domain(&recording_domains, &headers));
// Test with no subdomain - should NOT match
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://example.com".parse().unwrap());
assert!(!on_permitted_domain(&recording_domains, &headers));
// Test with wrong domain
let mut headers = HeaderMap::new();
headers.insert("Origin", "https://app.wrong.com".parse().unwrap());
assert!(!on_permitted_domain(&recording_domains, &headers));
}
// Tests for sample rate handling - verifies compatibility between Python cache and Rust
mod sample_rate_tests {
use super::*;
use axum::http::HeaderMap;
use rust_decimal::Decimal;
use std::str::FromStr;
fn create_team_with_sample_rate(sample_rate: Option<Decimal>) -> Team {
Team {
session_recording_opt_in: true,
session_recording_sample_rate: sample_rate,
..Team::default()
}
}
fn get_sample_rate_from_config(team: &Team) -> Option<String> {
let headers = HeaderMap::new();
match session_recording_config_response(team, &headers) {
Some(SessionRecordingField::Config(config)) => config.sample_rate.clone(),
_ => panic!("Expected Config response"),
}
}
#[test]
fn test_sample_rate_none_returns_none() {
// When sample_rate is None, should return None (no sampling configured)
let team = create_team_with_sample_rate(None);
assert_eq!(get_sample_rate_from_config(&team), None);
}
#[test]
fn test_sample_rate_100_percent_from_db_returns_none() {
// When sample_rate is 1.00 from PostgreSQL (preserves precision), should return None
// This simulates the PostgreSQL readthrough path where Decimal preserves "1.00"
let team = create_team_with_sample_rate(Some(Decimal::from_str("1.00").unwrap()));
assert_eq!(
get_sample_rate_from_config(&team),
None,
"100% sample rate (from DB with precision) should return None"
);
}
#[test]
fn test_sample_rate_80_percent_returns_value() {
// 80% sample rate should return "0.80"
let team = create_team_with_sample_rate(Some(Decimal::from_str("0.80").unwrap()));
assert_eq!(get_sample_rate_from_config(&team), Some("0.80".to_string()));
}
#[test]
fn test_sample_rate_50_percent_returns_value() {
// 50% sample rate should return "0.50"
let team = create_team_with_sample_rate(Some(Decimal::from_str("0.50").unwrap()));
assert_eq!(get_sample_rate_from_config(&team), Some("0.50".to_string()));
}
#[test]
fn test_sample_rate_0_percent_returns_value() {
// 0% sample rate should return "0.00" (record nothing)
let team = create_team_with_sample_rate(Some(Decimal::from_str("0.00").unwrap()));
assert_eq!(get_sample_rate_from_config(&team), Some("0.00".to_string()));
}
}
}