1#![allow(clippy::cast_ptr_alignment)]
3#![deny(unused_must_use)]
4#![allow(clippy::derive_partial_eq_without_eq)]
5
6use std::cmp::Ordering;
7use std::ffi::CStr;
8use std::os::raw::c_char;
9use std::slice;
10use std::sync::OnceLock;
11
12use chrono::{DateTime, Utc};
13use relay_cardinality::CardinalityLimit;
14use relay_dynamic_config::{normalize_json, GlobalConfig, ProjectConfig};
15use relay_event_normalization::{
16 normalize_event, validate_event, BreakdownsConfig, ClientHints, EventValidationConfig,
17 GeoIpLookup, NormalizationConfig, RawUserAgentInfo,
18};
19use relay_event_schema::processor::{process_value, split_chunks, ProcessingState};
20use relay_event_schema::protocol::{Event, IpAddr, VALID_PLATFORMS};
21use relay_pii::{
22 selector_suggestions_from_value, DataScrubbingConfig, InvalidSelectorError, PiiConfig,
23 PiiConfigError, PiiProcessor, SelectorSpec,
24};
25use relay_protocol::{Annotated, Remark, RuleCondition};
26use relay_sampling::SamplingConfig;
27use serde::{Deserialize, Serialize};
28use uuid::Uuid;
29
30use crate::core::RelayStr;
31
32#[derive(Serialize, Deserialize, Debug, Default)]
34#[serde(default)]
35pub struct StoreNormalizer {
36 pub project_id: Option<u64>,
38
39 pub client_ip: Option<IpAddr>,
44
45 pub client: Option<String>,
47
48 pub key_id: Option<String>,
52
53 pub protocol_version: Option<String>,
57
58 pub grouping_config: Option<serde_json::Value>,
63
64 pub user_agent: Option<String>,
72
73 pub client_hints: ClientHints<String>,
79
80 pub received_at: Option<DateTime<Utc>>,
84
85 pub sent_at: Option<DateTime<Utc>>,
90
91 pub max_secs_in_future: Option<i64>,
95
96 pub max_secs_in_past: Option<i64>,
100
101 pub enable_trimming: Option<bool>,
105
106 pub is_renormalize: Option<bool>,
115
116 pub remove_other: Option<bool>,
118
119 pub normalize_user_agent: Option<bool>,
121
122 pub breakdowns: Option<BreakdownsConfig>,
124
125 pub client_sample_rate: Option<f64>,
129
130 pub replay_id: Option<Uuid>,
134
135 pub normalize_spans: bool,
140}
141
142impl StoreNormalizer {
143 fn this(&self) -> &Self {
145 self
146 }
147}
148
149pub struct RelayGeoIpLookup;
151
152pub struct RelayStoreNormalizer;
154
155#[no_mangle]
157#[relay_ffi::catch_unwind]
158pub unsafe extern "C" fn relay_split_chunks(
159 string: *const RelayStr,
160 remarks: *const RelayStr,
161) -> RelayStr {
162 let remarks: Vec<Remark> = serde_json::from_str((*remarks).as_str())?;
163 let chunks = split_chunks((*string).as_str(), &remarks);
164 let json = serde_json::to_string(&chunks)?;
165 json.into()
166}
167
168#[no_mangle]
170#[relay_ffi::catch_unwind]
171pub unsafe extern "C" fn relay_geoip_lookup_new(path: *const c_char) -> *mut RelayGeoIpLookup {
172 let path = CStr::from_ptr(path).to_string_lossy();
173 let lookup = GeoIpLookup::open(path.as_ref())?;
174 Box::into_raw(Box::new(lookup)) as *mut RelayGeoIpLookup
175}
176
177#[no_mangle]
179#[relay_ffi::catch_unwind]
180pub unsafe extern "C" fn relay_geoip_lookup_free(lookup: *mut RelayGeoIpLookup) {
181 if !lookup.is_null() {
182 let lookup = lookup as *mut GeoIpLookup;
183 let _dropped = Box::from_raw(lookup);
184 }
185}
186
187#[no_mangle]
189#[relay_ffi::catch_unwind]
190pub unsafe extern "C" fn relay_valid_platforms(size_out: *mut usize) -> *const RelayStr {
191 static VALID_PLATFORM_STRS: OnceLock<Vec<RelayStr>> = OnceLock::new();
192 let platforms = VALID_PLATFORM_STRS
193 .get_or_init(|| VALID_PLATFORMS.iter().map(|s| RelayStr::new(s)).collect());
194
195 if let Some(size_out) = size_out.as_mut() {
196 *size_out = platforms.len();
197 }
198
199 platforms.as_ptr()
200}
201
202#[no_mangle]
204#[relay_ffi::catch_unwind]
205pub unsafe extern "C" fn relay_store_normalizer_new(
206 config: *const RelayStr,
207 _geoip_lookup: *const RelayGeoIpLookup,
208) -> *mut RelayStoreNormalizer {
209 let normalizer: StoreNormalizer = serde_json::from_str((*config).as_str())?;
210 Box::into_raw(Box::new(normalizer)) as *mut RelayStoreNormalizer
211}
212
213#[no_mangle]
215#[relay_ffi::catch_unwind]
216pub unsafe extern "C" fn relay_store_normalizer_free(normalizer: *mut RelayStoreNormalizer) {
217 if !normalizer.is_null() {
218 let normalizer = normalizer as *mut StoreNormalizer;
219 let _dropped = Box::from_raw(normalizer);
220 }
221}
222
223#[no_mangle]
225#[relay_ffi::catch_unwind]
226pub unsafe extern "C" fn relay_store_normalizer_normalize_event(
227 normalizer: *mut RelayStoreNormalizer,
228 event: *const RelayStr,
229) -> RelayStr {
230 let normalizer = normalizer as *mut StoreNormalizer;
231 let config = (*normalizer).this();
232 let mut event = Annotated::<Event>::from_json((*event).as_str())?;
233
234 let event_validation_config = EventValidationConfig {
235 received_at: config.received_at,
236 max_secs_in_past: config.max_secs_in_past,
237 max_secs_in_future: config.max_secs_in_future,
238 transaction_timestamp_range: None, is_validated: config.is_renormalize.unwrap_or(false),
240 };
241 validate_event(&mut event, &event_validation_config)?;
242
243 let is_renormalize = config.is_renormalize.unwrap_or(false);
244
245 let normalization_config = NormalizationConfig {
246 project_id: config.project_id,
247 client: config.client.clone(),
248 protocol_version: config.protocol_version.clone(),
249 key_id: config.key_id.clone(),
250 grouping_config: config.grouping_config.clone(),
251 client_ip: config.client_ip.as_ref(),
252 infer_ip_address: false, client_sample_rate: config.client_sample_rate,
254 user_agent: RawUserAgentInfo {
255 user_agent: config.user_agent.as_deref(),
256 client_hints: config.client_hints.as_deref(),
257 },
258 max_name_and_unit_len: None,
259 breakdowns_config: None, normalize_user_agent: config.normalize_user_agent,
261 transaction_name_config: Default::default(), is_renormalize,
263 remove_other: config.remove_other.unwrap_or(!is_renormalize),
264 emit_event_errors: !is_renormalize,
265 device_class_synthesis_config: false, enrich_spans: false,
267 max_tag_value_length: usize::MAX,
268 span_description_rules: None,
269 performance_score: None,
270 geoip_lookup: None, ai_model_costs: None, enable_trimming: config.enable_trimming.unwrap_or_default(),
273 measurements: None,
274 normalize_spans: config.normalize_spans,
275 replay_id: config.replay_id,
276 span_allowed_hosts: &[], span_op_defaults: Default::default(), performance_issues_spans: Default::default(),
279 };
280 normalize_event(&mut event, &normalization_config);
281
282 RelayStr::from_string(event.to_json()?)
283}
284
285#[no_mangle]
287#[relay_ffi::catch_unwind]
288pub unsafe extern "C" fn relay_translate_legacy_python_json(event: *mut RelayStr) -> bool {
289 let data = slice::from_raw_parts_mut((*event).data as *mut u8, (*event).len);
290 json_forensics::translate_slice(data);
291 true
292}
293
294#[no_mangle]
296#[relay_ffi::catch_unwind]
297pub unsafe extern "C" fn relay_validate_pii_selector(value: *const RelayStr) -> RelayStr {
298 let value = (*value).as_str();
299 match value.parse::<SelectorSpec>() {
300 Ok(_) => RelayStr::new(""),
301 Err(err) => match err {
302 InvalidSelectorError::ParseError(_) => {
303 RelayStr::from_string(format!("invalid syntax near {value:?}"))
306 }
307 err => RelayStr::from_string(err.to_string()),
308 },
309 }
310}
311
312#[no_mangle]
314#[relay_ffi::catch_unwind]
315pub unsafe extern "C" fn relay_validate_pii_config(value: *const RelayStr) -> RelayStr {
316 match serde_json::from_str::<PiiConfig>((*value).as_str()) {
317 Ok(config) => match config.compiled().force_compile() {
318 Ok(_) => RelayStr::new(""),
319 Err(PiiConfigError::RegexError(source)) => RelayStr::from_string(source.to_string()),
320 },
321 Err(e) => RelayStr::from_string(e.to_string()),
322 }
323}
324
325#[no_mangle]
327#[relay_ffi::catch_unwind]
328pub unsafe extern "C" fn relay_convert_datascrubbing_config(config: *const RelayStr) -> RelayStr {
329 let config: DataScrubbingConfig = serde_json::from_str((*config).as_str())?;
330 match config.pii_config() {
331 Ok(Some(config)) => RelayStr::from_string(serde_json::to_string(config)?),
332 Ok(None) => RelayStr::new("{}"),
333 Err(e) => RelayStr::from_string(e.to_string()),
335 }
336}
337
338#[no_mangle]
340#[relay_ffi::catch_unwind]
341pub unsafe extern "C" fn relay_pii_strip_event(
342 config: *const RelayStr,
343 event: *const RelayStr,
344) -> RelayStr {
345 let config = serde_json::from_str::<PiiConfig>((*config).as_str())?;
346 let mut processor = PiiProcessor::new(config.compiled());
347
348 let mut event = Annotated::<Event>::from_json((*event).as_str())?;
349 process_value(&mut event, &mut processor, ProcessingState::root())?;
350
351 RelayStr::from_string(event.to_json()?)
352}
353
354#[no_mangle]
357#[relay_ffi::catch_unwind]
358pub unsafe extern "C" fn relay_pii_selector_suggestions_from_event(
359 event: *const RelayStr,
360) -> RelayStr {
361 let mut event = Annotated::<Event>::from_json((*event).as_str())?;
362 let rv = selector_suggestions_from_value(&mut event);
363 RelayStr::from_string(serde_json::to_string(&rv)?)
364}
365
366#[no_mangle]
368#[relay_ffi::catch_unwind]
369#[allow(clippy::diverging_sub_expression)]
370pub unsafe extern "C" fn relay_test_panic() -> () {
371 panic!("this is a test panic")
372}
373
374#[no_mangle]
376#[relay_ffi::catch_unwind]
377pub unsafe extern "C" fn relay_parse_release(value: *const RelayStr) -> RelayStr {
378 let release = sentry_release_parser::Release::parse((*value).as_str())?;
379 RelayStr::from_string(serde_json::to_string(&release)?)
380}
381
382#[no_mangle]
384#[relay_ffi::catch_unwind]
385pub unsafe extern "C" fn relay_compare_versions(a: *const RelayStr, b: *const RelayStr) -> i32 {
386 let ver_a = sentry_release_parser::Version::parse((*a).as_str())?;
387 let ver_b = sentry_release_parser::Version::parse((*b).as_str())?;
388 match ver_a.cmp(&ver_b) {
389 Ordering::Less => -1,
390 Ordering::Equal => 0,
391 Ordering::Greater => 1,
392 }
393}
394
395#[no_mangle]
399#[relay_ffi::catch_unwind]
400pub unsafe extern "C" fn relay_validate_rule_condition(value: *const RelayStr) -> RelayStr {
401 let ret_val = match serde_json::from_str::<RuleCondition>((*value).as_str()) {
402 Ok(condition) => {
403 if condition.supported() {
404 "".to_string()
405 } else {
406 "unsupported condition".to_string()
407 }
408 }
409 Err(e) => e.to_string(),
410 };
411 RelayStr::from_string(ret_val)
412}
413
414#[no_mangle]
418#[relay_ffi::catch_unwind]
419pub unsafe extern "C" fn relay_validate_sampling_configuration(value: *const RelayStr) -> RelayStr {
420 match serde_json::from_str::<SamplingConfig>((*value).as_str()) {
421 Ok(config) => {
422 for rule in config.rules {
423 if !rule.condition.supported() {
424 return Ok(RelayStr::new("unsupported sampling rule"));
425 }
426 }
427 RelayStr::default()
428 }
429 Err(e) => RelayStr::from_string(e.to_string()),
430 }
431}
432
433#[no_mangle]
435#[relay_ffi::catch_unwind]
436pub unsafe extern "C" fn relay_normalize_project_config(value: *const RelayStr) -> RelayStr {
437 let value = (*value).as_str();
438 match normalize_json::<ProjectConfig>(value) {
439 Ok(normalized) => RelayStr::from_string(normalized),
440 Err(e) => RelayStr::from_string(e.to_string()),
441 }
442}
443
444#[no_mangle]
446#[relay_ffi::catch_unwind]
447pub unsafe extern "C" fn normalize_cardinality_limit_config(value: *const RelayStr) -> RelayStr {
448 let value = (*value).as_str();
449 match normalize_json::<CardinalityLimit>(value) {
450 Ok(normalized) => RelayStr::from_string(normalized),
451 Err(e) => RelayStr::from_string(e.to_string()),
452 }
453}
454
455#[no_mangle]
457#[relay_ffi::catch_unwind]
458pub unsafe extern "C" fn relay_normalize_global_config(value: *const RelayStr) -> RelayStr {
459 let value = (*value).as_str();
460 match normalize_json::<GlobalConfig>(value) {
461 Ok(normalized) => RelayStr::from_string(normalized),
462 Err(e) => RelayStr::from_string(e.to_string()),
463 }
464}
465
466#[cfg(test)]
467mod tests {
468 use super::*;
469
470 #[test]
471 fn pii_config_validation_invalid_regex() {
472 let config = r#"
473 {
474 "rules": {
475 "strip-fields": {
476 "type": "redact_pair",
477 "keyPattern": "(not valid regex",
478 "redaction": {
479 "method": "replace",
480 "text": "[Filtered]"
481 }
482 }
483 },
484 "applications": {
485 "*.everything": ["strip-fields"]
486 }
487 }
488 "#;
489 assert_eq!(
490 unsafe { relay_validate_pii_config(&RelayStr::from(config)).as_str() },
491 "regex parse error:\n (not valid regex\n ^\nerror: unclosed group"
492 );
493 }
494
495 #[test]
496 fn pii_config_validation_valid_regex() {
497 let config = r#"
498 {
499 "rules": {
500 "strip-fields": {
501 "type": "redact_pair",
502 "keyPattern": "(\\w+)?+",
503 "redaction": {
504 "method": "replace",
505 "text": "[Filtered]"
506 }
507 }
508 },
509 "applications": {
510 "*.everything": ["strip-fields"]
511 }
512 }
513 "#;
514 assert_eq!(
515 unsafe { relay_validate_pii_config(&RelayStr::from(config)).as_str() },
516 ""
517 );
518 }
519}