From ac52a53a60a6b3f45ae358468071fa39eeaf623c Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Thu, 14 May 2026 17:56:32 -0400 Subject: [PATCH 1/9] feat(bench): add AggOp memory profiler --- crates/beava-bench/Cargo.toml | 4 + crates/beava-bench/src/bin/memprofile.rs | 513 +++++++++++++++++++ crates/beava-bench/tests/memprofile_smoke.rs | 27 + crates/beava-core/src/lib.rs | 1 + crates/beava-core/src/mem_usage.rs | 493 ++++++++++++++++++ crates/beava-server/src/http_admin.rs | 7 +- memory-profile-fraud-team.md | 150 ++++++ 7 files changed, 1192 insertions(+), 3 deletions(-) create mode 100644 crates/beava-bench/src/bin/memprofile.rs create mode 100644 crates/beava-bench/tests/memprofile_smoke.rs create mode 100644 crates/beava-core/src/mem_usage.rs create mode 100644 memory-profile-fraud-team.md diff --git a/crates/beava-bench/Cargo.toml b/crates/beava-bench/Cargo.toml index fbc72632..4b5c4684 100644 --- a/crates/beava-bench/Cargo.toml +++ b/crates/beava-bench/Cargo.toml @@ -56,6 +56,10 @@ path = "src/lib.rs" name = "beava-bench" path = "src/bin/beava-bench.rs" +[[bin]] +name = "memprofile" +path = "src/bin/memprofile.rs" + [[bench]] name = "blast_shape_bench" harness = false diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs new file mode 100644 index 00000000..3d5b5f6e --- /dev/null +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -0,0 +1,513 @@ +//! Per-AggOp memory profile report for realistic workload configs. + +use anyhow::{anyhow, Context, Result}; +use beava_core::agg_op::{AggExtParams, AggKind, AggOp, AggOpDescriptor, SketchParams}; +use beava_core::mem_usage::{sort_profiles_desc, MemBreakdown, MemProfile, MemUsage}; +use beava_core::row::{Row, Value}; +use clap::Parser; +use serde_json::Value as JsonValue; +use std::collections::BTreeMap; +use std::fs; +use std::path::PathBuf; + +#[derive(Debug, Parser)] +#[command(name = "memprofile", about = "Profile per-AggOp memory usage")] +struct Args { + #[arg(long, default_value = "fraud")] + workload: String, + #[arg(long, default_value_t = 2_000)] + events: u64, + #[arg(long, default_value = "memory-profile-fraud-team.md")] + output: PathBuf, + #[arg(long, default_value_t = beava_server::http_admin::BYTES_PER_ENTITY_P99_V0_PLACEHOLDER)] + metrics_bytes_per_entity_p99: u64, + #[arg(long, default_value_t = 0.15)] + tolerance: f64, +} + +#[derive(Debug, Clone)] +struct FeatureSpec { + derivation: String, + feature: String, + op_name: String, + desc: AggOpDescriptor, +} + +#[derive(Debug, Clone)] +struct ProfileRow { + derivation: String, + feature: String, + op_name: String, + profile: MemProfile, + recommendation: String, +} + +struct ReportInput<'a> { + workload: &'a str, + events: u64, + derivation_count: usize, + feature_count: usize, + rows: &'a [ProfileRow], + op_totals: &'a [MemProfile], + per_entity_total: usize, + metrics_placeholder: u64, + tolerance: f64, +} + +fn main() -> Result<()> { + let args = Args::parse(); + let report = build_report(&args)?; + fs::write(&args.output, report).with_context(|| format!("write {}", args.output.display()))?; + eprintln!("memprofile: wrote {}", args.output.display()); + Ok(()) +} + +fn build_report(args: &Args) -> Result { + let workload = beava_bench::workloads::load_by_name(&args.workload) + .with_context(|| format!("load workload {:?}", args.workload))?; + let features = feature_specs_from_register(&workload.register_payload)?; + let mut rows = Vec::with_capacity(features.len()); + + for spec in &features { + let mut op = AggOp::new(&spec.desc); + let field = spec.desc.field.as_deref(); + for i in 0..args.events { + let row = synthetic_row(i); + op.update(&row, 1_000_000 + i as i64 * 1_000, field, true); + } + let mut profile = op.mem_profile(); + profile.label = format!("{}::{} ({})", spec.derivation, spec.feature, spec.op_name); + rows.push(ProfileRow { + derivation: spec.derivation.clone(), + feature: spec.feature.clone(), + op_name: spec.op_name.clone(), + recommendation: recommendation_for(&spec.op_name, &profile), + profile, + }); + } + + rows.sort_by(|a, b| { + b.profile + .total_bytes() + .cmp(&a.profile.total_bytes()) + .then_with(|| a.profile.label.cmp(&b.profile.label)) + }); + + let mut grouped: BTreeMap> = BTreeMap::new(); + for row in &rows { + grouped + .entry(row.op_name.clone()) + .or_default() + .push(row.profile.clone()); + } + let mut op_totals: Vec = grouped + .into_iter() + .map(|(op, profiles)| { + let mut total = MemProfile::new(op, 0); + for profile in profiles { + total.stack_bytes += profile.stack_bytes; + total.heap_bytes += profile.heap_bytes; + total.breakdown.extend(profile.breakdown); + } + total + }) + .collect(); + sort_profiles_desc(&mut op_totals); + + let per_entity_total: usize = rows.iter().map(|r| r.profile.total_bytes()).sum(); + Ok(render_markdown(ReportInput { + workload: &args.workload, + events: args.events, + derivation_count: workload.derivations.len(), + feature_count: features.len(), + rows: &rows, + op_totals: &op_totals, + per_entity_total, + metrics_placeholder: args.metrics_bytes_per_entity_p99, + tolerance: args.tolerance, + })) +} + +fn render_markdown(input: ReportInput<'_>) -> String { + let mut out = String::new(); + out.push_str("# AggOp Memory Profile: fraud-team\n\n"); + out.push_str("## Workload Summary\n\n"); + out.push_str(&format!("- Workload: `{}`\n", input.workload)); + out.push_str(&format!("- Events replayed per op: `{}`\n", input.events)); + out.push_str(&format!( + "- Derivations discovered: `{}`\n", + input.derivation_count + )); + out.push_str(&format!( + "- Aggregate features discovered: `{}`\n", + input.feature_count + )); + out.push_str(&format!( + "- Per-entity structural estimate: `{}` bytes\n\n", + input.per_entity_total + )); + + out.push_str("## Sorted Op Table\n\n"); + out.push_str("| Rank | Op | Stack bytes | Heap bytes | Total bytes |\n"); + out.push_str("|------|----|-------------|------------|-------------|\n"); + for (idx, profile) in input.op_totals.iter().enumerate() { + out.push_str(&format!( + "| {} | `{}` | {} | {} | {} |\n", + idx + 1, + profile.label, + profile.stack_bytes, + profile.heap_bytes, + profile.total_bytes() + )); + } + + out.push_str("\n## Top 5 Offenders\n\n"); + for (idx, row) in input.rows.iter().take(5).enumerate() { + out.push_str(&format!( + "### {}. `{}` / `{}` / `{}`\n\n", + idx + 1, + row.derivation, + row.feature, + row.op_name + )); + out.push_str(&format!( + "- Bytes: stack={} heap={} total={}\n", + row.profile.stack_bytes, + row.profile.heap_bytes, + row.profile.total_bytes() + )); + out.push_str(&format!("- Recommendation: {}\n", row.recommendation)); + out.push_str("- Breakdown:\n"); + for entry in top_breakdown(&row.profile.breakdown, 8) { + out.push_str(&format!( + " - `{}`: {} bytes ({}, {})\n", + entry.label, entry.bytes, entry.kind, entry.note + )); + } + out.push('\n'); + } + + out.push_str("## Metrics Coherence\n\n"); + let target = input.metrics_placeholder as f64; + let observed = input.per_entity_total as f64; + let delta = (observed - target).abs(); + let allowed = target * input.tolerance; + out.push_str(&format!( + "- `/metrics` `beava_bytes_per_entity_p99`: `{}` bytes\n", + input.metrics_placeholder + )); + out.push_str(&format!( + "- Profile per-entity estimate: `{}` bytes\n", + input.per_entity_total + )); + out.push_str(&format!("- Tolerance: `{:.1}%`\n", input.tolerance * 100.0)); + if delta <= allowed { + out.push_str( + "- Assertion: PASS - profile estimate is coherent with metrics placeholder.\n", + ); + } else { + out.push_str(&format!( + "- Assertion: bytes_per_entity_p99 diverged by {:.0} bytes; file sibling work to replace the static placeholder with live sampling.\n", + delta + )); + } + + out.push_str("\n## Notes\n\n"); + out.push_str("- `stack_bytes` is the inline `AggOp` enum slot for each feature.\n"); + out.push_str("- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate.\n"); + out +} + +fn top_breakdown(entries: &[MemBreakdown], limit: usize) -> Vec { + let mut entries = entries.to_vec(); + entries.sort_by(|a, b| b.bytes.cmp(&a.bytes).then_with(|| a.label.cmp(&b.label))); + entries.truncate(limit); + entries +} + +fn recommendation_for(op_name: &str, profile: &MemProfile) -> String { + match op_name { + "quantile" | "n_unique" | "top_k" | "bloom_member" | "entropy" => { + "keep for now; quantify sparse-to-dense sketch options next".to_string() + } + "burst_count" | "trend_residual" if profile.stack_bytes >= 80 => { + "box smaller if the report confirms broad per-entity prevalence".to_string() + } + "count" | "sum" | "mean" if profile.heap_bytes == 0 => { + "keep; scalar state spends only the shared AggOp slot".to_string() + } + _ if op_name.contains("window") || profile.label.contains("Windowed") => { + "restructure only if lazy bucket materialization still dominates".to_string() + } + _ => "keep; no targeted restructuring until workload ranking justifies it".to_string(), + } +} + +fn feature_specs_from_register(register: &JsonValue) -> Result> { + let nodes = register + .get("nodes") + .and_then(JsonValue::as_array) + .ok_or_else(|| anyhow!("register payload missing nodes[]"))?; + let mut out = Vec::new(); + for node in nodes + .iter() + .filter(|n| n.get("kind") == Some(&JsonValue::String("derivation".into()))) + { + let derivation = node + .get("name") + .and_then(JsonValue::as_str) + .unwrap_or("unknown_derivation") + .to_string(); + let Some(ops) = node.get("ops").and_then(JsonValue::as_array) else { + continue; + }; + for step in ops { + let Some(agg) = step.get("agg").and_then(JsonValue::as_object) else { + continue; + }; + for (feature, spec) in agg { + let op_name = spec + .get("op") + .and_then(JsonValue::as_str) + .ok_or_else(|| anyhow!("feature {feature} missing op"))? + .to_string(); + let params = spec.get("params").unwrap_or(&JsonValue::Null); + out.push(FeatureSpec { + derivation: derivation.clone(), + feature: feature.clone(), + desc: descriptor_from_op(&op_name, params)?, + op_name, + }); + } + } + } + Ok(out) +} + +fn descriptor_from_op(op_name: &str, params: &JsonValue) -> Result { + let kind = agg_kind_from_name(op_name)?; + let mut desc = AggOpDescriptor { + kind, + field: string_param(params, "field").or_else(|| string_param(params, "expr")), + window_ms: duration_param(params, "window")?, + n: number_param(params, "n").map(|n| n as u32), + half_life_ms: duration_param(params, "half_life")?, + sub_window_ms: duration_param(params, "sub_window")?, + sigma: float_param(params, "sigma"), + sketch_params: Some(SketchParams { + percentile_q: float_param(params, "q"), + top_k_k: number_param(params, "k"), + bloom_capacity: number_param(params, "capacity"), + bloom_fpr: float_param(params, "fpr"), + }), + ext: AggExtParams { + buckets: array_f64_param(params, "buckets"), + n: number_param(params, "n"), + k: number_param(params, "k"), + precision: number_param(params, "precision").map(|n| n as u32), + lat_field: string_param(params, "lat"), + lon_field: string_param(params, "lon"), + samples: number_param(params, "samples"), + categories: string_array_param(params, "categories"), + max_categories: number_param(params, "max_categories"), + ..Default::default() + }, + ..Default::default() + }; + if desc.field.is_none() && matches!(kind, AggKind::BloomMember | AggKind::Entropy) { + desc.field = Some("__expr".into()); + } + Ok(desc) +} + +fn agg_kind_from_name(name: &str) -> Result { + let kind = match name { + "count" => AggKind::Count, + "sum" => AggKind::Sum, + "mean" => AggKind::Avg, + "min" => AggKind::Min, + "max" => AggKind::Max, + "var" => AggKind::Variance, + "std" => AggKind::StdDev, + "quantile" => AggKind::Percentile, + "n_unique" => AggKind::CountDistinct, + "top_k" => AggKind::TopK, + "bloom_member" => AggKind::BloomMember, + "entropy" => AggKind::Entropy, + "first" => AggKind::First, + "last" => AggKind::Last, + "first_n" => AggKind::FirstN, + "last_n" => AggKind::LastN, + "lag" => AggKind::Lag, + "first_seen" => AggKind::FirstSeen, + "last_seen" => AggKind::LastSeen, + "age" => AggKind::Age, + "has_seen" => AggKind::HasSeen, + "time_since" => AggKind::TimeSince, + "time_since_last_n" => AggKind::TimeSinceLastN, + "first_seen_in_window" => AggKind::FirstSeenInWindow, + "streak" => AggKind::Streak, + "max_streak" => AggKind::MaxStreak, + "negative_streak" => AggKind::NegativeStreak, + "ewma" => AggKind::Ewma, + "ewvar" => AggKind::EwVar, + "ew_zscore" => AggKind::EwZScore, + "decayed_sum" => AggKind::DecayedSum, + "decayed_count" => AggKind::DecayedCount, + "twa" => AggKind::Twa, + "rate_of_change" => AggKind::RateOfChange, + "inter_arrival_stats" => AggKind::InterArrivalStats, + "burst_count" => AggKind::BurstCount, + "delta_from_prev" => AggKind::DeltaFromPrev, + "trend" => AggKind::Trend, + "trend_residual" => AggKind::TrendResidual, + "outlier_count" => AggKind::OutlierCount, + "value_change_count" => AggKind::ValueChangeCount, + "z_score" => AggKind::ZScore, + "histogram" => AggKind::Histogram, + "hour_of_day_histogram" => AggKind::HourOfDayHistogram, + "dow_hour_histogram" => AggKind::DowHourHistogram, + "seasonal_deviation" => AggKind::SeasonalDeviation, + "event_type_mix" => AggKind::EventTypeMix, + "most_recent_n" => AggKind::MostRecentN, + "reservoir_sample" => AggKind::ReservoirSample, + "geo_velocity" => AggKind::GeoVelocity, + "geo_distance" => AggKind::GeoDistance, + "geo_spread" => AggKind::GeoSpread, + "distance_from_home" => AggKind::DistanceFromHome, + other => return Err(anyhow!("unsupported agg op {other:?}")), + }; + Ok(kind) +} + +fn synthetic_row(i: u64) -> Row { + let key = format!("k{:08}", i % 100_000); + Row::new() + .with_field("event_time", Value::I64(1_000_000 + i as i64 * 1_000)) + .with_field("user_id", Value::Str(key.clone().into())) + .with_field("card_fp", Value::Str(format!("card{}", i % 2_048).into())) + .with_field("device_id", Value::Str(format!("dev{}", i % 4_096).into())) + .with_field( + "ip_address", + Value::Str(format!("10.0.{}.{}", (i / 255) % 255, i % 255).into()), + ) + .with_field("merchant_id", Value::Str(format!("m{}", i % 512).into())) + .with_field("mcc", Value::Str(format!("{}", 5000 + i % 120).into())) + .with_field("amount", Value::F64(((i % 10_000) as f64) / 3.0 + 1.0)) + .with_field( + "card_country", + Value::Str((if i % 3 == 0 { "US" } else { "CA" }).into()), + ) + .with_field( + "ip_country", + Value::Str((if i % 5 == 0 { "GB" } else { "US" }).into()), + ) + .with_field("billing_country", Value::Str("US".into())) + .with_field("lat", Value::F64(37.0 + (i % 100) as f64 * 0.001)) + .with_field("lon", Value::F64(-122.0 - (i % 100) as f64 * 0.001)) + .with_field("declined", Value::I64((i % 7 == 0) as i64)) + .with_field("success", Value::I64((i % 11 != 0) as i64)) + .with_field("is_chargeback", Value::I64((i % 13 == 0) as i64)) + .with_field("user_agent", Value::Str(format!("ua{}", i % 64).into())) + .with_field("email", Value::Str(format!("u{}@x.test", i % 2048).into())) + .with_field( + "email_domain", + Value::Str(format!("d{}.test", i % 64).into()), + ) + .with_field("ssn_hash", Value::Str(format!("ssn{}", i % 8192).into())) + .with_field("__expr", Value::Str(format!("cell{}", i % 4096).into())) +} + +fn string_param(params: &JsonValue, key: &str) -> Option { + params + .get(key) + .and_then(JsonValue::as_str) + .map(str::to_string) +} + +fn number_param(params: &JsonValue, key: &str) -> Option { + params + .get(key) + .and_then(JsonValue::as_u64) + .map(|n| n as usize) +} + +fn float_param(params: &JsonValue, key: &str) -> Option { + params.get(key).and_then(JsonValue::as_f64) +} + +fn array_f64_param(params: &JsonValue, key: &str) -> Option> { + params.get(key)?.as_array().map(|items| { + items + .iter() + .filter_map(JsonValue::as_f64) + .collect::>() + }) +} + +fn string_array_param(params: &JsonValue, key: &str) -> Option> { + params.get(key)?.as_array().map(|items| { + items + .iter() + .filter_map(JsonValue::as_str) + .map(str::to_string) + .collect::>() + }) +} + +fn duration_param(params: &JsonValue, key: &str) -> Result> { + let Some(raw) = params.get(key).and_then(JsonValue::as_str) else { + return Ok(None); + }; + parse_duration_ms(raw) + .map(Some) + .with_context(|| format!("parse duration param {key}={raw:?}")) +} + +fn parse_duration_ms(raw: &str) -> Result { + let raw = raw.trim(); + let split_at = raw + .find(|c: char| !c.is_ascii_digit()) + .ok_or_else(|| anyhow!("duration missing unit: {raw}"))?; + let (n, unit) = raw.split_at(split_at); + let n: u64 = n.parse()?; + let multiplier = match unit { + "ms" => 1, + "s" => 1_000, + "m" => 60_000, + "h" => 3_600_000, + "d" => 86_400_000, + _ => return Err(anyhow!("unsupported duration unit {unit:?}")), + }; + Ok(n.saturating_mul(multiplier)) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn memprofile_duration_parser_handles_fraud_units() { + assert_eq!(parse_duration_ms("10s").unwrap(), 10_000); + assert_eq!(parse_duration_ms("5m").unwrap(), 300_000); + assert_eq!(parse_duration_ms("24h").unwrap(), 86_400_000); + assert_eq!(parse_duration_ms("30d").unwrap(), 2_592_000_000); + } + + #[test] + fn memprofile_report_contains_required_sections() { + let args = Args { + workload: "fraud".into(), + events: 5, + output: PathBuf::from("/tmp/unused.md"), + metrics_bytes_per_entity_p99: 7_000, + tolerance: 0.15, + }; + let report = build_report(&args).unwrap(); + assert!(report.contains("# AggOp Memory Profile: fraud-team")); + assert!(report.contains("## Sorted Op Table")); + assert!(report.contains("## Top 5 Offenders")); + assert!(report.contains("## Metrics Coherence")); + assert!(report.contains("Aggregate features discovered: `111`")); + } +} diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs new file mode 100644 index 00000000..27bf1482 --- /dev/null +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -0,0 +1,27 @@ +use assert_cmd::Command; + +#[test] +fn memprofile_smoke_writes_required_sections() { + let temp = tempfile::tempdir().expect("tempdir"); + let output = temp.path().join("memory-profile-fraud-team.md"); + + Command::cargo_bin("memprofile") + .expect("memprofile binary") + .args([ + "--workload", + "fraud", + "--events", + "5", + "--output", + output.to_str().expect("utf8 path"), + ]) + .assert() + .success(); + + let report = std::fs::read_to_string(output).expect("read report"); + assert!(report.contains("# AggOp Memory Profile: fraud-team")); + assert!(report.contains("## Sorted Op Table")); + assert!(report.contains("## Top 5 Offenders")); + assert!(report.contains("## Metrics Coherence")); + assert!(report.contains("Aggregate features discovered: `111`")); +} diff --git a/crates/beava-core/src/lib.rs b/crates/beava-core/src/lib.rs index b7a097e9..2694dd24 100644 --- a/crates/beava-core/src/lib.rs +++ b/crates/beava-core/src/lib.rs @@ -19,6 +19,7 @@ pub mod defaults; pub mod eval; pub mod expr; pub mod expr_builtins; +pub mod mem_usage; pub mod op_chain; pub mod op_node; pub mod register_validate; diff --git a/crates/beava-core/src/mem_usage.rs b/crates/beava-core/src/mem_usage.rs new file mode 100644 index 00000000..809a7b8d --- /dev/null +++ b/crates/beava-core/src/mem_usage.rs @@ -0,0 +1,493 @@ +//! Deterministic structural memory accounting for aggregation state. +//! +//! This is intentionally not allocator instrumentation. It reports stable, +//! platform-independent estimates from owned state shape: inline stack slots, +//! `Box` payloads, vector capacity, sketch backing stores, and documented +//! map overhead estimates. + +use crate::agg_op::AggOp; +use crate::row::Value; +use serde::Serialize; +use std::collections::VecDeque; +use std::mem::{size_of, size_of_val}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct MemBreakdown { + pub label: String, + pub bytes: usize, + pub kind: String, + pub note: String, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct MemProfile { + pub label: String, + pub stack_bytes: usize, + pub heap_bytes: usize, + pub breakdown: Vec, +} + +impl MemProfile { + pub fn new(label: impl Into, stack_bytes: usize) -> Self { + Self { + label: label.into(), + stack_bytes, + heap_bytes: 0, + breakdown: Vec::new(), + } + } + + pub fn total_bytes(&self) -> usize { + self.stack_bytes + self.heap_bytes + } + + pub fn add_breakdown( + &mut self, + label: impl Into, + bytes: usize, + kind: impl Into, + note: impl Into, + ) { + if bytes == 0 { + return; + } + self.heap_bytes = self.heap_bytes.saturating_add(bytes); + self.breakdown.push(MemBreakdown { + label: label.into(), + bytes, + kind: kind.into(), + note: note.into(), + }); + } + + pub fn absorb_nested(&mut self, prefix: &str, nested: MemProfile) { + self.add_breakdown( + format!("{prefix} stack payload"), + nested.stack_bytes, + "nested_stack", + "nested AggOp stored inside an owned heap allocation", + ); + for entry in nested.breakdown { + self.add_breakdown( + format!("{prefix} / {}", entry.label), + entry.bytes, + entry.kind, + entry.note, + ); + } + } +} + +pub trait MemUsage { + fn mem_profile(&self) -> MemProfile; +} + +pub fn sort_profiles_desc(rows: &mut [MemProfile]) { + rows.sort_by(|a, b| { + b.total_bytes() + .cmp(&a.total_bytes()) + .then_with(|| a.label.cmp(&b.label)) + }); +} + +pub fn vec_heap_bytes(vec: &Vec) -> usize { + vec.capacity().saturating_mul(size_of::()) +} + +pub fn vecdeque_heap_bytes(deque: &VecDeque) -> usize { + deque.capacity().saturating_mul(size_of::()) +} + +pub fn serialized_heap_estimate(value: &T) -> usize { + serde_json::to_vec(value).map(|v| v.len()).unwrap_or(0) +} + +pub fn estimated_btree_map_heap_bytes(len: usize, key_value_bytes: usize) -> usize { + const BTREE_ENTRY_OVERHEAD: usize = 32; + len.saturating_mul(key_value_bytes.saturating_add(BTREE_ENTRY_OVERHEAD)) +} + +pub fn estimated_hash_map_heap_bytes(capacity: usize, key_value_bytes: usize) -> usize { + const HASH_ENTRY_OVERHEAD: usize = 24; + capacity.saturating_mul(key_value_bytes.saturating_add(HASH_ENTRY_OVERHEAD)) +} + +#[cfg(test)] +fn serde_profile(label: &str, value: &T) -> MemProfile { + let mut profile = MemProfile::new(label, size_of_val(value)); + profile.add_breakdown( + format!("{label} serialized owned state estimate"), + serialized_heap_estimate(value), + "estimate", + "deterministic serialized-size proxy for private owned heap fields", + ); + profile +} + +fn value_vec_breakdown(profile: &mut MemProfile, label: &str, values: &Vec) { + profile.add_breakdown( + label, + vec_heap_bytes(values), + "Vec", + "capacity * size_of::()", + ); +} + +fn value_deque_breakdown(profile: &mut MemProfile, label: &str, values: &VecDeque) { + profile.add_breakdown( + label, + vecdeque_heap_bytes(values), + "VecDeque", + "capacity * size_of::()", + ); +} + +impl MemUsage for AggOp { + fn mem_profile(&self) -> MemProfile { + let mut profile = MemProfile::new(aggop_label(self), size_of::()); + match self { + AggOp::Count(_) + | AggOp::Sum(_) + | AggOp::Avg(_) + | AggOp::Min(_) + | AggOp::Max(_) + | AggOp::Variance(_) + | AggOp::StdDev(_) + | AggOp::Ratio(_) + | AggOp::First(_) + | AggOp::Last(_) + | AggOp::FirstSeen(_) + | AggOp::LastSeen(_) + | AggOp::Age(_) + | AggOp::HasSeen(_) + | AggOp::TimeSince(_) + | AggOp::Streak(_) + | AggOp::MaxStreak(_) + | AggOp::NegativeStreak(_) + | AggOp::FirstSeenInWindow(_) + | AggOp::Ewma(_) + | AggOp::EwVar(_) + | AggOp::EwZScore(_) + | AggOp::DecayedSum(_) + | AggOp::DecayedCount(_) + | AggOp::Twa(_) + | AggOp::RateOfChange(_) + | AggOp::InterArrivalStats(_) + | AggOp::DeltaFromPrev(_) + | AggOp::Trend(_) + | AggOp::TrendResidual(_) + | AggOp::OutlierCount(_) + | AggOp::ValueChangeCount(_) + | AggOp::ZScore(_) => {} + + AggOp::FirstN(s) => value_vec_breakdown(&mut profile, "FirstN values", &s.values), + AggOp::LastN(s) => value_deque_breakdown(&mut profile, "LastN values", &s.values), + AggOp::Lag(s) => value_deque_breakdown(&mut profile, "Lag values", &s.values), + AggOp::TimeSinceLastN(s) => profile.add_breakdown( + "TimeSinceLastN timestamps", + vecdeque_heap_bytes(&s.times_ms), + "VecDeque", + "capacity * size_of::()", + ), + AggOp::BurstCount(op) => { + profile.add_breakdown( + "BurstCount buckets", + vec_heap_bytes(&op.state.buckets), + "Vec", + "capacity * size_of::()", + ); + profile.add_breakdown( + "BurstCount bucket_epoch", + vec_heap_bytes(&op.state.bucket_epoch), + "Vec", + "capacity * size_of::()", + ); + } + AggOp::Histogram(s) => { + profile.add_breakdown( + "Histogram split points", + vec_heap_bytes(&s.buckets), + "Vec", + "capacity * size_of::()", + ); + profile.add_breakdown( + "Histogram counts", + vec_heap_bytes(&s.counts), + "Vec", + "capacity * size_of::()", + ); + } + AggOp::DowHourHistogram(s) => profile.add_breakdown( + "DowHourHistogram counts", + vec_heap_bytes(&s.counts), + "Vec", + "capacity * size_of::()", + ), + AggOp::MostRecentN(s) => { + value_vec_breakdown(&mut profile, "MostRecentN buffer", &s.buf) + } + AggOp::ReservoirSample(s) => { + value_vec_breakdown(&mut profile, "ReservoirSample reservoir", &s.reservoir) + } + AggOp::EventTypeMix(s) => { + let boxed_bytes = size_of_val(&**s); + profile.add_breakdown( + "Box", + boxed_bytes, + "Box", + "heap allocation for boxed payload", + ); + profile.add_breakdown( + "EventTypeMix BTreeMap entries", + estimated_btree_map_heap_bytes(s.counts.len(), 48), + "BTreeMap", + "estimated node overhead plus String/u64 payload", + ); + if let Some(allowed) = &s.allowed { + profile.add_breakdown( + "EventTypeMix allowed categories", + vec_heap_bytes(allowed), + "Vec", + "capacity * size_of::()", + ); + } + } + AggOp::HourOfDayHistogram(s) => { + add_boxed_serialized(&mut profile, "HourOfDayHistogram", &**s) + } + AggOp::SeasonalDeviation(s) => { + add_boxed_serialized(&mut profile, "SeasonalDeviation", &**s) + } + AggOp::GeoVelocity(s) => add_boxed_serialized(&mut profile, "GeoVelocity", &**s), + AggOp::GeoDistance(s) => add_boxed_serialized(&mut profile, "GeoDistance", &**s), + AggOp::GeoSpread(s) => add_boxed_serialized(&mut profile, "GeoSpread", &**s), + AggOp::DistanceFromHome(s) => { + profile.add_breakdown( + "Box", + size_of_val(&**s), + "Box", + "heap allocation for boxed payload", + ); + profile.add_breakdown( + "DistanceFromHome coordinate buffer", + vec_heap_bytes(&s.buf), + "Vec", + "capacity * size_of::<(f64, f64)>()", + ); + } + + AggOp::CountDistinct(s) => add_boxed_serialized(&mut profile, "CountDistinct", &**s), + AggOp::Percentile(s) => add_boxed_serialized(&mut profile, "Percentile", &**s), + AggOp::TopK(s) => add_boxed_serialized(&mut profile, "TopK", &**s), + AggOp::BloomMember(s) => add_boxed_serialized(&mut profile, "BloomMember", &**s), + AggOp::Entropy(s) => add_boxed_serialized(&mut profile, "Entropy", &**s), + + AggOp::Windowed(w) => { + profile.add_breakdown( + "Box", + size_of_val(&**w), + "Box", + "heap allocation for boxed WindowedOp payload", + ); + if w.buckets.spilled() { + profile.add_breakdown( + "WindowedOp spilled bucket SmallVec", + w.buckets + .capacity() + .saturating_mul(size_of::<(i64, Box)>()), + "SmallVec", + "spilled capacity * size_of::<(i64, Box)>()", + ); + } + for (idx, (_, bucket)) in w.buckets.iter().enumerate() { + let nested = bucket.mem_profile(); + profile.add_breakdown( + format!("Windowed bucket {idx} Box"), + size_of::(), + "Box", + "heap allocation for bucket AggOp enum slot", + ); + for entry in nested.breakdown { + profile.add_breakdown( + format!("Windowed bucket {idx} / {}", entry.label), + entry.bytes, + entry.kind, + entry.note, + ); + } + } + } + } + profile + } +} + +fn add_boxed_serialized(profile: &mut MemProfile, label: &str, value: &T) { + profile.add_breakdown( + format!("Box<{label}>"), + size_of_val(value), + "Box", + "heap allocation for boxed payload", + ); + profile.add_breakdown( + format!("{label} owned internals"), + serialized_heap_estimate(value), + "estimate", + "deterministic serialized-size proxy for private sketch/container internals", + ); +} + +fn aggop_label(op: &AggOp) -> String { + match op { + AggOp::Count(_) => "Count", + AggOp::Sum(_) => "Sum", + AggOp::Avg(_) => "Avg", + AggOp::Min(_) => "Min", + AggOp::Max(_) => "Max", + AggOp::Variance(_) => "Variance", + AggOp::StdDev(_) => "StdDev", + AggOp::Ratio(_) => "Ratio", + AggOp::CountDistinct(_) => "CountDistinct", + AggOp::Percentile(_) => "Percentile", + AggOp::TopK(_) => "TopK", + AggOp::BloomMember(_) => "BloomMember", + AggOp::Entropy(_) => "Entropy", + AggOp::Windowed(_) => "Windowed", + AggOp::First(_) => "First", + AggOp::Last(_) => "Last", + AggOp::FirstN(_) => "FirstN", + AggOp::LastN(_) => "LastN", + AggOp::Lag(_) => "Lag", + AggOp::FirstSeen(_) => "FirstSeen", + AggOp::LastSeen(_) => "LastSeen", + AggOp::Age(_) => "Age", + AggOp::HasSeen(_) => "HasSeen", + AggOp::TimeSince(_) => "TimeSince", + AggOp::TimeSinceLastN(_) => "TimeSinceLastN", + AggOp::Streak(_) => "Streak", + AggOp::MaxStreak(_) => "MaxStreak", + AggOp::NegativeStreak(_) => "NegativeStreak", + AggOp::FirstSeenInWindow(_) => "FirstSeenInWindow", + AggOp::Ewma(_) => "Ewma", + AggOp::EwVar(_) => "EwVar", + AggOp::EwZScore(_) => "EwZScore", + AggOp::DecayedSum(_) => "DecayedSum", + AggOp::DecayedCount(_) => "DecayedCount", + AggOp::Twa(_) => "Twa", + AggOp::RateOfChange(_) => "RateOfChange", + AggOp::InterArrivalStats(_) => "InterArrivalStats", + AggOp::BurstCount(_) => "BurstCount", + AggOp::DeltaFromPrev(_) => "DeltaFromPrev", + AggOp::Trend(_) => "Trend", + AggOp::TrendResidual(_) => "TrendResidual", + AggOp::OutlierCount(_) => "OutlierCount", + AggOp::ValueChangeCount(_) => "ValueChangeCount", + AggOp::ZScore(_) => "ZScore", + AggOp::Histogram(_) => "Histogram", + AggOp::HourOfDayHistogram(_) => "HourOfDayHistogram", + AggOp::DowHourHistogram(_) => "DowHourHistogram", + AggOp::SeasonalDeviation(_) => "SeasonalDeviation", + AggOp::EventTypeMix(_) => "EventTypeMix", + AggOp::MostRecentN(_) => "MostRecentN", + AggOp::ReservoirSample(_) => "ReservoirSample", + AggOp::GeoVelocity(_) => "GeoVelocity", + AggOp::GeoDistance(_) => "GeoDistance", + AggOp::GeoSpread(_) => "GeoSpread", + AggOp::DistanceFromHome(_) => "DistanceFromHome", + } + .to_string() +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::agg_op::{AggKind, AggOp, AggOpDescriptor}; + use crate::row::{Row, Value}; + + #[test] + fn mem_usage_total_bytes_adds_stack_and_heap() { + let mut profile = MemProfile::new("sample", 80); + profile.add_breakdown("vec", 32, "Vec", "test"); + profile.add_breakdown("box", 16, "Box", "test"); + assert_eq!(profile.total_bytes(), 128); + } + + #[test] + fn mem_usage_scalar_aggop_reports_enum_stack_slot() { + let profile = AggOp::Count(Default::default()).mem_profile(); + assert_eq!(profile.stack_bytes, size_of::()); + } + + #[test] + fn mem_usage_boxed_sketch_reports_box_breakdown() { + let profile = AggOp::new(&AggOpDescriptor { + kind: AggKind::Percentile, + ..Default::default() + }) + .mem_profile(); + assert!(profile.breakdown.iter().any(|b| b.label.contains("Box"))); + } + + #[test] + fn mem_usage_vector_backed_state_reports_capacity_bytes() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::FirstN, + field: Some("merchant_id".into()), + n: Some(5), + ..Default::default() + }); + let row = Row::new().with_field("merchant_id", Value::Str("m1".into())); + op.update(&row, 1, Some("merchant_id"), true); + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "FirstN values" && b.bytes >= size_of::())); + } + + #[test] + fn mem_usage_windowed_state_reports_nested_bucket() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::Sum, + field: Some("amount".into()), + window_ms: Some(60_000), + ..Default::default() + }); + let row = Row::new().with_field("amount", Value::F64(42.0)); + op.update(&row, 1_000, Some("amount"), true); + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label.contains("Windowed bucket 0 Box"))); + } + + #[test] + fn mem_usage_map_backed_state_labels_estimate() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::EventTypeMix, + field: Some("mcc".into()), + ..Default::default() + }); + let row = Row::new().with_field("mcc", Value::Str("5411".into())); + op.update(&row, 1, Some("mcc"), true); + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.note.contains("estimated"))); + } + + #[test] + fn mem_usage_sort_profiles_desc_orders_by_total_bytes() { + let mut rows = vec![MemProfile::new("small", 1), MemProfile::new("large", 10)]; + sort_profiles_desc(&mut rows); + assert_eq!(rows[0].label, "large"); + } + + #[test] + fn serde_profile_estimate_is_deterministic() { + let profile = serde_profile("value", &serde_json::json!({"a": 1})); + assert!(profile.heap_bytes > 0); + } +} diff --git a/crates/beava-server/src/http_admin.rs b/crates/beava-server/src/http_admin.rs index 8314f115..4bafe24d 100644 --- a/crates/beava-server/src/http_admin.rs +++ b/crates/beava-server/src/http_admin.rs @@ -47,6 +47,10 @@ pub struct RegistrySnapshot { pub type SharedRegistrySnapshot = Arc>; +/// Static v0 estimate from PROJECT.md "Memory" budget (~7 KB per entity +/// for a rich 30-feature pack). A periodic resampler is post-v0 work. +pub const BYTES_PER_ENTITY_P99_V0_PLACEHOLDER: u64 = 7000; + #[derive(Clone)] struct AdminState { snapshot: SharedRegistrySnapshot, @@ -86,9 +90,6 @@ async fn metrics_handler(State(state): State) -> impl IntoResponse { let cold_evictions = ColdEntityEvictionCounter::count(); let bucket_reclaims = BucketReclaimCounter::count(); let entity_count = EntityCountResidentSnapshot::load(); - // Static v0 estimate from PROJECT.md "Memory" budget (~7 KB per entity - // for a rich 30-feature pack). A periodic resampler is post-v0 work. - const BYTES_PER_ENTITY_P99_V0_PLACEHOLDER: u64 = 7000; // The lifetime-op aggregate counter currently aliases entropy // `categories_capped`; top-k displacement and histogram bucket drops // join when those operator internals expose hooks. diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md new file mode 100644 index 00000000..0b47007c --- /dev/null +++ b/memory-profile-fraud-team.md @@ -0,0 +1,150 @@ +# AggOp Memory Profile: fraud-team + +## Workload Summary + +- Workload: `fraud` +- Events replayed per op: `2000` +- Derivations discovered: `9` +- Aggregate features discovered: `111` +- Per-entity structural estimate: `405997` bytes + +## Sorted Op Table + +| Rank | Op | Stack bytes | Heap bytes | Total bytes | +|------|----|-------------|------------|-------------| +| 1 | `n_unique` | 1200 | 299930 | 301130 | +| 2 | `count` | 1440 | 30864 | 32304 | +| 3 | `top_k` | 160 | 18366 | 18526 | +| 4 | `quantile` | 320 | 13481 | 13801 | +| 5 | `event_type_mix` | 80 | 9728 | 9808 | +| 6 | `sum` | 320 | 4576 | 4896 | +| 7 | `entropy` | 160 | 4308 | 4468 | +| 8 | `bloom_member` | 80 | 3308 | 3388 | +| 9 | `burst_count` | 240 | 3072 | 3312 | +| 10 | `distance_from_home` | 80 | 1720 | 1800 | +| 11 | `reservoir_sample` | 80 | 1600 | 1680 | +| 12 | `seasonal_deviation` | 80 | 1427 | 1507 | +| 13 | `dow_hour_histogram` | 80 | 1344 | 1424 | +| 14 | `geo_velocity` | 160 | 372 | 532 | +| 15 | `mean` | 80 | 416 | 496 | +| 16 | `min` | 80 | 416 | 496 | +| 17 | `std` | 80 | 416 | 496 | +| 18 | `var` | 80 | 416 | 496 | +| 19 | `first_seen` | 400 | 0 | 400 | +| 20 | `first_n` | 80 | 256 | 336 | +| 21 | `hour_of_day_histogram` | 80 | 255 | 335 | +| 22 | `geo_spread` | 80 | 251 | 331 | +| 23 | `age` | 320 | 0 | 320 | +| 24 | `negative_streak` | 320 | 0 | 320 | +| 25 | `geo_distance` | 80 | 171 | 251 | +| 26 | `last_n` | 80 | 160 | 240 | +| 27 | `last_seen` | 240 | 0 | 240 | +| 28 | `most_recent_n` | 80 | 160 | 240 | +| 29 | `time_since` | 240 | 0 | 240 | +| 30 | `decayed_count` | 160 | 0 | 160 | +| 31 | `first_seen_in_window` | 160 | 0 | 160 | +| 32 | `streak` | 160 | 0 | 160 | +| 33 | `lag` | 80 | 64 | 144 | +| 34 | `time_since_last_n` | 80 | 40 | 120 | +| 35 | `decayed_sum` | 80 | 0 | 80 | +| 36 | `delta_from_prev` | 80 | 0 | 80 | +| 37 | `ew_zscore` | 80 | 0 | 80 | +| 38 | `ewma` | 80 | 0 | 80 | +| 39 | `ewvar` | 80 | 0 | 80 | +| 40 | `first` | 80 | 0 | 80 | +| 41 | `has_seen` | 80 | 0 | 80 | +| 42 | `inter_arrival_stats` | 80 | 0 | 80 | +| 43 | `last` | 80 | 0 | 80 | +| 44 | `max` | 80 | 0 | 80 | +| 45 | `max_streak` | 80 | 0 | 80 | +| 46 | `outlier_count` | 80 | 0 | 80 | +| 47 | `rate_of_change` | 80 | 0 | 80 | +| 48 | `trend` | 80 | 0 | 80 | +| 49 | `trend_residual` | 80 | 0 | 80 | +| 50 | `twa` | 80 | 0 | 80 | +| 51 | `value_change_count` | 80 | 0 | 80 | +| 52 | `z_score` | 80 | 0 | 80 | + +## Top 5 Offenders + +### 1. `LoginByUser` / `ips_distinct_login_1h` / `n_unique` + +- Bytes: stack=80 heap=48449 total=48529 +- Recommendation: keep for now; quantify sparse-to-dense sketch options next +- Breakdown: + - `Windowed bucket 7 / CountDistinct owned internals`: 1228 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 31 / CountDistinct owned internals`: 1224 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 23 / CountDistinct owned internals`: 1221 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 3 / CountDistinct owned internals`: 1220 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 27 / CountDistinct owned internals`: 1219 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 19 / CountDistinct owned internals`: 1217 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 35 / CountDistinct owned internals`: 1214 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 15 / CountDistinct owned internals`: 1213 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + +### 2. `TxnByIp` / `cards_per_ip_1h` / `n_unique` + +- Bytes: stack=80 heap=48397 total=48477 +- Recommendation: keep for now; quantify sparse-to-dense sketch options next +- Breakdown: + - `Windowed bucket 19 / CountDistinct owned internals`: 1221 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 27 / CountDistinct owned internals`: 1220 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 35 / CountDistinct owned internals`: 1219 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 11 / CountDistinct owned internals`: 1216 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 15 / CountDistinct owned internals`: 1215 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 3 / CountDistinct owned internals`: 1215 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 23 / CountDistinct owned internals`: 1209 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 31 / CountDistinct owned internals`: 1209 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + +### 3. `TxnByCard` / `merchants_per_card_24h` / `n_unique` + +- Bytes: stack=80 heap=24391 total=24471 +- Recommendation: keep for now; quantify sparse-to-dense sketch options next +- Breakdown: + - `Windowed bucket 1 / CountDistinct owned internals`: 10494 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 0 / CountDistinct owned internals`: 7188 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 2 / CountDistinct owned internals`: 6173 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed payload) + +### 4. `TxnByUser` / `merchants_distinct_24h` / `n_unique` + +- Bytes: stack=80 heap=24391 total=24471 +- Recommendation: keep for now; quantify sparse-to-dense sketch options next +- Breakdown: + - `Windowed bucket 1 / CountDistinct owned internals`: 10494 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 0 / CountDistinct owned internals`: 7188 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 2 / CountDistinct owned internals`: 6173 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed payload) + +### 5. `TxnByDevice` / `cards_per_device_24h` / `n_unique` + +- Bytes: stack=80 heap=22174 total=22254 +- Recommendation: keep for now; quantify sparse-to-dense sketch options next +- Breakdown: + - `Windowed bucket 1 / CountDistinct owned internals`: 8259 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 0 / CountDistinct owned internals`: 7205 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 2 / CountDistinct owned internals`: 6174 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed payload) + +## Metrics Coherence + +- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes +- Profile per-entity estimate: `405997` bytes +- Tolerance: `15.0%` +- Assertion: bytes_per_entity_p99 diverged by 398997 bytes; file sibling work to replace the static placeholder with live sampling. + +## Notes + +- `stack_bytes` is the inline `AggOp` enum slot for each feature. +- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. From 34a572f0812d76ee70c36a96ee6a95324288e114 Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Thu, 14 May 2026 22:57:45 -0400 Subject: [PATCH 2/9] Lifetime vs window, better sketches size measure --- crates/beava-bench/src/bin/memprofile.rs | 180 ++++++++++-- crates/beava-bench/tests/memprofile_smoke.rs | 8 +- crates/beava-core/src/mem_usage.rs | 268 +++++++++++++++++- crates/beava-core/src/sketches/bloom.rs | 3 + crates/beava-core/src/sketches/cms.rs | 24 ++ .../beava-core/src/sketches/count_distinct.rs | 7 + crates/beava-core/src/sketches/entropy.rs | 4 + crates/beava-core/src/sketches/hll.rs | 4 + crates/beava-core/src/sketches/uddsketch.rs | 25 ++ memory-profile-adtech.md | 97 +++++++ memory-profile-ecommerce.md | 129 +++++++++ memory-profile-fraud-team.md | 265 +++++++++-------- memory-profile-medium.md | 68 +++++ 13 files changed, 938 insertions(+), 144 deletions(-) create mode 100644 memory-profile-adtech.md create mode 100644 memory-profile-ecommerce.md create mode 100644 memory-profile-medium.md diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs index 3d5b5f6e..c423b763 100644 --- a/crates/beava-bench/src/bin/memprofile.rs +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -2,7 +2,7 @@ use anyhow::{anyhow, Context, Result}; use beava_core::agg_op::{AggExtParams, AggKind, AggOp, AggOpDescriptor, SketchParams}; -use beava_core::mem_usage::{sort_profiles_desc, MemBreakdown, MemProfile, MemUsage}; +use beava_core::mem_usage::{MemBreakdown, MemProfile, MemUsage}; use beava_core::row::{Row, Value}; use clap::Parser; use serde_json::Value as JsonValue; @@ -38,17 +38,41 @@ struct ProfileRow { derivation: String, feature: String, op_name: String, + shape: ProfileShape, + window_ms: Option, profile: MemProfile, recommendation: String, } +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +enum ProfileShape { + Lifetime, + Windowed, +} + +impl ProfileShape { + fn as_str(self) -> &'static str { + match self { + Self::Lifetime => "lifetime", + Self::Windowed => "windowed", + } + } +} + +#[derive(Debug, Clone)] +struct OpTotal { + op_name: String, + shape: ProfileShape, + profile: MemProfile, +} + struct ReportInput<'a> { workload: &'a str, events: u64, derivation_count: usize, feature_count: usize, rows: &'a [ProfileRow], - op_totals: &'a [MemProfile], + op_totals: &'a [OpTotal], per_entity_total: usize, metrics_placeholder: u64, tolerance: f64, @@ -77,11 +101,14 @@ fn build_report(args: &Args) -> Result { } let mut profile = op.mem_profile(); profile.label = format!("{}::{} ({})", spec.derivation, spec.feature, spec.op_name); + let shape = profile_shape(&spec.desc); rows.push(ProfileRow { derivation: spec.derivation.clone(), feature: spec.feature.clone(), op_name: spec.op_name.clone(), - recommendation: recommendation_for(&spec.op_name, &profile), + shape, + window_ms: spec.desc.window_ms, + recommendation: recommendation_for(&spec.op_name, shape, &profile), profile, }); } @@ -93,26 +120,36 @@ fn build_report(args: &Args) -> Result { .then_with(|| a.profile.label.cmp(&b.profile.label)) }); - let mut grouped: BTreeMap> = BTreeMap::new(); + let mut grouped: BTreeMap<(String, ProfileShape), Vec> = BTreeMap::new(); for row in &rows { grouped - .entry(row.op_name.clone()) + .entry((row.op_name.clone(), row.shape)) .or_default() .push(row.profile.clone()); } - let mut op_totals: Vec = grouped + let mut op_totals: Vec = grouped .into_iter() - .map(|(op, profiles)| { - let mut total = MemProfile::new(op, 0); + .map(|((op_name, shape), profiles)| { + let mut total = MemProfile::new(op_name.clone(), 0); for profile in profiles { total.stack_bytes += profile.stack_bytes; total.heap_bytes += profile.heap_bytes; total.breakdown.extend(profile.breakdown); } - total + OpTotal { + op_name, + shape, + profile: total, + } }) .collect(); - sort_profiles_desc(&mut op_totals); + op_totals.sort_by(|a, b| { + b.profile + .total_bytes() + .cmp(&a.profile.total_bytes()) + .then_with(|| a.op_name.cmp(&b.op_name)) + .then_with(|| a.shape.cmp(&b.shape)) + }); let per_entity_total: usize = rows.iter().map(|r| r.profile.total_bytes()).sum(); Ok(render_markdown(ReportInput { @@ -148,16 +185,17 @@ fn render_markdown(input: ReportInput<'_>) -> String { )); out.push_str("## Sorted Op Table\n\n"); - out.push_str("| Rank | Op | Stack bytes | Heap bytes | Total bytes |\n"); - out.push_str("|------|----|-------------|------------|-------------|\n"); + out.push_str("| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes |\n"); + out.push_str("|------|----|-------|-------------|------------|-------------|\n"); for (idx, profile) in input.op_totals.iter().enumerate() { out.push_str(&format!( - "| {} | `{}` | {} | {} | {} |\n", + "| {} | `{}` | `{}` | {} | {} | {} |\n", idx + 1, - profile.label, - profile.stack_bytes, - profile.heap_bytes, - profile.total_bytes() + profile.op_name, + profile.shape.as_str(), + profile.profile.stack_bytes, + profile.profile.heap_bytes, + profile.profile.total_bytes() )); } @@ -176,8 +214,24 @@ fn render_markdown(input: ReportInput<'_>) -> String { row.profile.heap_bytes, row.profile.total_bytes() )); + out.push_str(&format!( + "- Shape: `{}`{}\n", + row.shape.as_str(), + format_window_suffix(row.window_ms) + )); out.push_str(&format!("- Recommendation: {}\n", row.recommendation)); - out.push_str("- Breakdown:\n"); + if row.shape == ProfileShape::Windowed { + out.push_str("- Breakdown rollup:\n"); + for entry in windowed_rollup(&row.profile.breakdown) { + out.push_str(&format!( + " - `{}`: {} bytes ({}, {})\n", + entry.label, entry.bytes, entry.kind, entry.note + )); + } + out.push_str("- Raw breakdown:\n"); + } else { + out.push_str("- Breakdown:\n"); + } for entry in top_breakdown(&row.profile.breakdown, 8) { out.push_str(&format!( " - `{}`: {} bytes ({}, {})\n", @@ -225,24 +279,99 @@ fn top_breakdown(entries: &[MemBreakdown], limit: usize) -> Vec { entries } -fn recommendation_for(op_name: &str, profile: &MemProfile) -> String { - match op_name { - "quantile" | "n_unique" | "top_k" | "bloom_member" | "entropy" => { - "keep for now; quantify sparse-to-dense sketch options next".to_string() +fn windowed_rollup(entries: &[MemBreakdown]) -> Vec { + let mut grouped: BTreeMap = BTreeMap::new(); + for entry in entries { + let Some((label, kind, note)) = windowed_rollup_bucket(entry) else { + continue; + }; + let slot = grouped.entry(label.clone()).or_insert(MemBreakdown { + label, + bytes: 0, + kind, + note, + }); + slot.bytes = slot.bytes.saturating_add(entry.bytes); + } + let mut rolled = grouped.into_values().collect::>(); + rolled.sort_by(|a, b| b.bytes.cmp(&a.bytes).then_with(|| a.label.cmp(&b.label))); + rolled +} + +fn windowed_rollup_bucket(entry: &MemBreakdown) -> Option<(String, String, String)> { + if entry.label == "Box" || entry.label == "WindowedOp spilled bucket SmallVec" { + return Some(( + "Windowed wrapper overhead".to_string(), + "WindowedOp".to_string(), + "summed boxed WindowedOp payload and spilled bucket storage".to_string(), + )); + } + if entry.label.starts_with("Windowed bucket ") && entry.label.ends_with(" Box") { + return Some(( + "Windowed bucket shell overhead".to_string(), + "Box".to_string(), + "summed boxed AggOp enum slots across active buckets".to_string(), + )); + } + let (_, nested) = entry.label.split_once(" / ")?; + Some(( + format!("{nested} across buckets"), + entry.kind.clone(), + "summed across active window buckets".to_string(), + )) +} + +fn recommendation_for(op_name: &str, shape: ProfileShape, profile: &MemProfile) -> String { + match (op_name, shape) { + ("n_unique", ProfileShape::Windowed) => { + "keep for now; quantify sketch precision and window bucket fanout separately" + .to_string() } - "burst_count" | "trend_residual" if profile.stack_bytes >= 80 => { + ("count" | "sum" | "mean", ProfileShape::Windowed) => { + "keep scalar core; quantify whether wrapper and bucket fanout are the real cost" + .to_string() + } + ( + "quantile" | "n_unique" | "top_k" | "bloom_member" | "entropy", + ProfileShape::Lifetime, + ) => "keep for now; quantify sparse-to-dense sketch options next".to_string(), + ("burst_count" | "trend_residual", _) if profile.stack_bytes >= 80 => { "box smaller if the report confirms broad per-entity prevalence".to_string() } - "count" | "sum" | "mean" if profile.heap_bytes == 0 => { + ("count" | "sum" | "mean", _) if profile.heap_bytes == 0 => { "keep; scalar state spends only the shared AggOp slot".to_string() } - _ if op_name.contains("window") || profile.label.contains("Windowed") => { + (_, ProfileShape::Windowed) => { "restructure only if lazy bucket materialization still dominates".to_string() } _ => "keep; no targeted restructuring until workload ranking justifies it".to_string(), } } +fn profile_shape(desc: &AggOpDescriptor) -> ProfileShape { + if desc.window_ms.is_some() { + ProfileShape::Windowed + } else { + ProfileShape::Lifetime + } +} + +fn format_window_suffix(window_ms: Option) -> String { + window_ms + .map(|ms| format!(" ({})", format_duration_ms(ms))) + .unwrap_or_default() +} + +fn format_duration_ms(ms: u64) -> String { + match ms { + ms if ms % 86_400_000 == 0 => format!("{}d", ms / 86_400_000), + ms if ms % 3_600_000 == 0 => format!("{}h", ms / 3_600_000), + ms if ms % 60_000 == 0 => format!("{}m", ms / 60_000), + ms if ms % 1_000 == 0 => format!("{}s", ms / 1_000), + ms => format!("{ms}ms"), + } +} + fn feature_specs_from_register(register: &JsonValue) -> Result> { let nodes = register .get("nodes") @@ -509,5 +638,6 @@ mod tests { assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); + assert!(report.contains("| Rank | Op | Shape |")); } } diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs index 27bf1482..1b26d8cb 100644 --- a/crates/beava-bench/tests/memprofile_smoke.rs +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -11,7 +11,7 @@ fn memprofile_smoke_writes_required_sections() { "--workload", "fraud", "--events", - "5", + "50", "--output", output.to_str().expect("utf8 path"), ]) @@ -24,4 +24,10 @@ fn memprofile_smoke_writes_required_sections() { assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); + assert!(report.contains("| Rank | Op | Shape |")); + assert!(report.contains("`windowed`")); + assert!(report.contains("`lifetime`")); + assert!(report.contains("- Breakdown rollup:")); + assert!(report.contains("Windowed wrapper overhead")); + assert!(!report.contains("CountDistinct owned internals")); } diff --git a/crates/beava-core/src/mem_usage.rs b/crates/beava-core/src/mem_usage.rs index 809a7b8d..c24c35eb 100644 --- a/crates/beava-core/src/mem_usage.rs +++ b/crates/beava-core/src/mem_usage.rs @@ -6,7 +6,15 @@ //! map overhead estimates. use crate::agg_op::AggOp; +use crate::agg_state::{ + BloomMemberStateWrap, CountDistinctStateWrap, EntropyStateWrap, PercentileStateWrap, + TopKStateWrap, +}; use crate::row::Value; +use crate::sketches::cms::TopKValue; +use crate::sketches::count_distinct::CountDistinctState; +use crate::sketches::percentile::PercentileState; +use crate::sketches::top_k::TopKState; use serde::Serialize; use std::collections::VecDeque; use std::mem::{size_of, size_of_val}; @@ -142,6 +150,160 @@ fn value_deque_breakdown(profile: &mut MemProfile, label: &str, values: &VecDequ ); } +fn add_box_allocation( + profile: &mut MemProfile, + label: impl Into, + bytes: usize, + note: impl Into, +) { + profile.add_breakdown(label, bytes, "Box", note); +} + +fn add_count_distinct_breakdown(profile: &mut MemProfile, state: &CountDistinctStateWrap) { + add_box_allocation( + profile, + "Box", + size_of_val(state), + "heap allocation for boxed CountDistinct wrapper", + ); + match &state.inner { + CountDistinctState::ExactArray { values } => profile.add_breakdown( + "CountDistinct exact-array values", + vec_heap_bytes(values), + "Vec", + "capacity * size_of::() for exact distinct hashes", + ), + CountDistinctState::HashSet { .. } => profile.add_breakdown( + "CountDistinct hash-set slots", + state + .inner + .hash_set_capacity() + .unwrap_or(0) + .saturating_mul(16), + "HashSet", + "estimated hashbrown slot cost for u64 distinct hashes", + ), + CountDistinctState::Hll { sketch } => profile.add_breakdown( + "CountDistinct HLL registers", + sketch.register_capacity().saturating_mul(size_of::()), + "Vec", + "capacity * size_of::() for dense HLL registers", + ), + } +} + +fn add_percentile_breakdown(profile: &mut MemProfile, state: &PercentileStateWrap) { + add_box_allocation( + profile, + "Box", + size_of_val(state), + "heap allocation for boxed Percentile wrapper", + ); + match &state.inner { + PercentileState::Exact { values, .. } => profile.add_breakdown( + "Percentile exact samples", + vec_heap_bytes(values), + "Vec", + "capacity * size_of::() for exact percentile samples", + ), + PercentileState::Sketch { sketch } => { + profile.add_breakdown( + "UDDSketch positive buckets", + sketch + .positive_bucket_capacity() + .saturating_mul(size_of::<(i32, u64)>()), + "Vec", + "capacity * size_of::<(i32, u64)>() for positive UDDSketch buckets", + ); + profile.add_breakdown( + "UDDSketch negative buckets", + sketch + .negative_bucket_capacity() + .saturating_mul(size_of::<(i32, u64)>()), + "Vec", + "capacity * size_of::<(i32, u64)>() for negative UDDSketch buckets", + ); + } + } +} + +fn add_top_k_breakdown(profile: &mut MemProfile, state: &TopKStateWrap) { + add_box_allocation( + profile, + "Box", + size_of_val(state), + "heap allocation for boxed TopK wrapper", + ); + match &state.inner { + TopKState::Exact { counts, .. } => profile.add_breakdown( + "TopK exact BTreeMap entries", + estimated_btree_map_heap_bytes(counts.len(), 64), + "BTreeMap", + "estimated node overhead plus TopKValue/u64 payloads", + ), + TopKState::Hybrid { cms, heap, .. } => { + profile.add_breakdown( + "TopK count-min counters", + cms.counter_capacity().saturating_mul(size_of::()), + "Vec", + "capacity * size_of::() for count-min sketch counters", + ); + profile.add_breakdown( + "TopK heap entries", + heap.heap_capacity() + .saturating_mul(size_of::<(u64, TopKValue)>()), + "Vec", + "capacity * size_of::<(u64, TopKValue)>() for bounded top-k heap entries", + ); + profile.add_breakdown( + "TopK heap index map", + estimated_hash_map_heap_bytes( + heap.index_capacity_estimate(), + size_of::<(TopKValue, usize)>(), + ), + "AHashMap", + "estimated slot cost for TopK heap-position side index", + ); + } + } +} + +fn add_bloom_breakdown(profile: &mut MemProfile, state: &BloomMemberStateWrap) { + add_box_allocation( + profile, + "Box", + size_of_val(state), + "heap allocation for boxed Bloom wrapper", + ); + profile.add_breakdown( + "Bloom filter words", + state.inner.word_capacity().saturating_mul(size_of::()), + "Vec", + "capacity * size_of::() for bloom bit-array storage", + ); +} + +fn add_entropy_breakdown(profile: &mut MemProfile, state: &EntropyStateWrap) { + add_box_allocation( + profile, + "Box", + size_of_val(state), + "heap allocation for boxed Entropy wrapper", + ); + profile.add_breakdown( + "Entropy category map entries", + estimated_btree_map_heap_bytes(state.inner.category_count(), 48), + "BTreeMap", + "estimated node overhead plus String/u64 category payloads", + ); + profile.add_breakdown( + "Entropy category string capacity", + state.inner.key_capacity_bytes(), + "String", + "sum of tracked category string capacities", + ); +} + impl MemUsage for AggOp { fn mem_profile(&self) -> MemProfile { let mut profile = MemProfile::new(aggop_label(self), size_of::()); @@ -276,11 +438,11 @@ impl MemUsage for AggOp { ); } - AggOp::CountDistinct(s) => add_boxed_serialized(&mut profile, "CountDistinct", &**s), - AggOp::Percentile(s) => add_boxed_serialized(&mut profile, "Percentile", &**s), - AggOp::TopK(s) => add_boxed_serialized(&mut profile, "TopK", &**s), - AggOp::BloomMember(s) => add_boxed_serialized(&mut profile, "BloomMember", &**s), - AggOp::Entropy(s) => add_boxed_serialized(&mut profile, "Entropy", &**s), + AggOp::CountDistinct(s) => add_count_distinct_breakdown(&mut profile, s), + AggOp::Percentile(s) => add_percentile_breakdown(&mut profile, s), + AggOp::TopK(s) => add_top_k_breakdown(&mut profile, s), + AggOp::BloomMember(s) => add_bloom_breakdown(&mut profile, s), + AggOp::Entropy(s) => add_entropy_breakdown(&mut profile, s), AggOp::Windowed(w) => { profile.add_breakdown( @@ -428,6 +590,102 @@ mod tests { assert!(profile.breakdown.iter().any(|b| b.label.contains("Box"))); } + #[test] + fn mem_usage_count_distinct_reports_mode_specific_components() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::CountDistinct, + field: Some("merchant_id".into()), + ..Default::default() + }); + for i in 0..32 { + let row = Row::new().with_field("merchant_id", Value::Str(format!("m{i}").into())); + op.update(&row, i as i64, Some("merchant_id"), true); + } + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "CountDistinct hash-set slots")); + } + + #[test] + fn mem_usage_percentile_sketch_reports_uddsketch_vectors() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::Percentile, + field: Some("amount".into()), + ..Default::default() + }); + for i in 0..300 { + let row = Row::new().with_field("amount", Value::F64(i as f64 + 1.0)); + op.update(&row, i as i64, Some("amount"), true); + } + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "UDDSketch positive buckets")); + } + + #[test] + fn mem_usage_top_k_hybrid_reports_cms_and_heap_components() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::TopK, + field: Some("merchant_id".into()), + ..Default::default() + }); + for i in 0..1100 { + let row = Row::new().with_field("merchant_id", Value::Str(format!("m{i}").into())); + op.update(&row, i as i64, Some("merchant_id"), true); + } + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "TopK count-min counters")); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "TopK heap index map")); + } + + #[test] + fn mem_usage_bloom_reports_filter_words() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::BloomMember, + field: Some("email_domain".into()), + ..Default::default() + }); + let row = Row::new().with_field("email_domain", Value::Str("risk.test".into())); + op.update(&row, 1, Some("email_domain"), true); + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "Bloom filter words")); + } + + #[test] + fn mem_usage_entropy_reports_category_map_components() { + let mut op = AggOp::new(&AggOpDescriptor { + kind: AggKind::Entropy, + field: Some("mcc".into()), + ..Default::default() + }); + for value in ["5411", "5732", "5812"] { + let row = Row::new().with_field("mcc", Value::Str(value.into())); + op.update(&row, 1, Some("mcc"), true); + } + let profile = op.mem_profile(); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "Entropy category map entries")); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "Entropy category string capacity")); + } + #[test] fn mem_usage_vector_backed_state_reports_capacity_bytes() { let mut op = AggOp::new(&AggOpDescriptor { diff --git a/crates/beava-core/src/sketches/bloom.rs b/crates/beava-core/src/sketches/bloom.rs index 9eb0079d..0462f1ae 100644 --- a/crates/beava-core/src/sketches/bloom.rs +++ b/crates/beava-core/src/sketches/bloom.rs @@ -50,6 +50,9 @@ impl BloomFilter { pub fn num_hashes(&self) -> u32 { self.num_hashes } + pub fn word_capacity(&self) -> usize { + self.words.capacity() + } fn base_hashes(&self, value: &str) -> (u64, u64) { // Use process-static RandomState instead of per-call diff --git a/crates/beava-core/src/sketches/cms.rs b/crates/beava-core/src/sketches/cms.rs index 068e842c..ec6b9c55 100644 --- a/crates/beava-core/src/sketches/cms.rs +++ b/crates/beava-core/src/sketches/cms.rs @@ -121,6 +121,10 @@ impl CountMinSketch { self.total } + pub fn counter_capacity(&self) -> usize { + self.counters.capacity() + } + #[inline] fn rehash(hash: u64, seed: u64) -> u64 { let mut h = hash ^ seed; @@ -357,6 +361,26 @@ impl TopKHeap { out } + pub fn heap_capacity(&self) -> usize { + self.heap.capacity() + } + + pub fn index_entry_count_estimate(&self) -> usize { + if self.index_ready { + self.index.len() + } else { + self.heap.len() + } + } + + pub fn index_capacity_estimate(&self) -> usize { + if self.index_ready { + self.index.capacity() + } else { + self.heap.capacity() + } + } + pub fn estimated_bytes(&self) -> usize { std::mem::size_of::() + self.heap.len() * (std::mem::size_of::() + 32) diff --git a/crates/beava-core/src/sketches/count_distinct.rs b/crates/beava-core/src/sketches/count_distinct.rs index 735388af..94caab69 100644 --- a/crates/beava-core/src/sketches/count_distinct.rs +++ b/crates/beava-core/src/sketches/count_distinct.rs @@ -88,6 +88,13 @@ impl CountDistinctState { } } + pub fn hash_set_capacity(&self) -> Option { + match self { + CountDistinctState::HashSet { hashes } => Some(hashes.capacity()), + _ => None, + } + } + /// Insert a precomputed u64 hash. Promotes mode if threshold exceeded. /// /// The input u64 is expected to come from a FxHasher-backed hasher; diff --git a/crates/beava-core/src/sketches/entropy.rs b/crates/beava-core/src/sketches/entropy.rs index 28c574f9..37237f5a 100644 --- a/crates/beava-core/src/sketches/entropy.rs +++ b/crates/beava-core/src/sketches/entropy.rs @@ -57,6 +57,10 @@ impl EntropyHistogram { self.counts.len() } + pub fn key_capacity_bytes(&self) -> usize { + self.counts.keys().map(|k| k.capacity()).sum() + } + pub fn insert(&mut self, value: &str) { self.total = self.total.saturating_add(1); // 1) Already-tracked key → bump and return. diff --git a/crates/beava-core/src/sketches/hll.rs b/crates/beava-core/src/sketches/hll.rs index 11458e40..84e2f9c1 100644 --- a/crates/beava-core/src/sketches/hll.rs +++ b/crates/beava-core/src/sketches/hll.rs @@ -105,6 +105,10 @@ impl Hll { Self::default() } + pub fn register_capacity(&self) -> usize { + self.registers.capacity() + } + /// SplitMix64 — improves the avalanche / uniform-distribution properties /// of the input hash, which is critical for HLL accuracy when callers /// pass hashes from a non-cryptographic hasher (ahash etc.). diff --git a/crates/beava-core/src/sketches/uddsketch.rs b/crates/beava-core/src/sketches/uddsketch.rs index 7f915de0..6f306726 100644 --- a/crates/beava-core/src/sketches/uddsketch.rs +++ b/crates/beava-core/src/sketches/uddsketch.rs @@ -106,6 +106,31 @@ impl UDDSketch { self.total_count } + #[inline] + pub fn positive_bucket_capacity(&self) -> usize { + self.pos_buckets.capacity() + } + + #[inline] + pub fn negative_bucket_capacity(&self) -> usize { + self.neg_buckets.capacity() + } + + #[inline] + pub fn positive_bucket_len(&self) -> usize { + self.pos_buckets.len() + } + + #[inline] + pub fn negative_bucket_len(&self) -> usize { + self.neg_buckets.len() + } + + #[inline] + pub fn zero_count(&self) -> u64 { + self.zero_count + } + #[inline] pub fn is_empty(&self) -> bool { self.total_count == 0 diff --git a/memory-profile-adtech.md b/memory-profile-adtech.md new file mode 100644 index 00000000..af1ea61f --- /dev/null +++ b/memory-profile-adtech.md @@ -0,0 +1,97 @@ +# AggOp Memory Profile: fraud-team + +## Workload Summary + +- Workload: `adtech` +- Events replayed per op: `2000` +- Derivations discovered: `1` +- Aggregate features discovered: `7` +- Per-entity structural estimate: `1122600` bytes + +## Sorted Op Table + +| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | +|------|----|-------|-------------|------------|-------------| +| 1 | `n_unique` | `windowed` | 80 | 1037960 | 1038040 | +| 2 | `quantile` | `windowed` | 80 | 84080 | 84160 | +| 3 | `count` | `lifetime` | 80 | 0 | 80 | +| 4 | `max` | `lifetime` | 80 | 0 | 80 | +| 5 | `mean` | `lifetime` | 80 | 0 | 80 | +| 6 | `min` | `lifetime` | 80 | 0 | 80 | +| 7 | `sum` | `lifetime` | 80 | 0 | 80 | + +## Top 5 Offenders + +### 1. `TxnAgg` / `merchants_distinct_1h` / `n_unique` + +- Bytes: stack=80 heap=1037960 total=1038040 +- Shape: `windowed` (1h) +- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Breakdown rollup: + - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) +- Raw breakdown: + - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + +### 2. `TxnAgg` / `amount_p99_1h` / `quantile` + +- Bytes: stack=80 heap=84080 total=84160 +- Shape: `windowed` (1h) +- Recommendation: restructure only if lazy bucket materialization still dominates +- Breakdown rollup: + - `Percentile exact samples across buckets`: 75776 bytes (Vec, summed across active window buckets) + - `Box across buckets`: 4144 bytes (Box, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) +- Raw breakdown: + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 1 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 10 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 11 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 12 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 13 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 14 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 15 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + +### 3. `TxnAgg` / `avg_amt` / `mean` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; scalar state spends only the shared AggOp slot +- Breakdown: + +### 4. `TxnAgg` / `cnt` / `count` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; scalar state spends only the shared AggOp slot +- Breakdown: + +### 5. `TxnAgg` / `max_amt` / `max` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; no targeted restructuring until workload ranking justifies it +- Breakdown: + +## Metrics Coherence + +- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes +- Profile per-entity estimate: `1122600` bytes +- Tolerance: `15.0%` +- Assertion: bytes_per_entity_p99 diverged by 1115600 bytes; file sibling work to replace the static placeholder with live sampling. + +## Notes + +- `stack_bytes` is the inline `AggOp` enum slot for each feature. +- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. diff --git a/memory-profile-ecommerce.md b/memory-profile-ecommerce.md new file mode 100644 index 00000000..002bd1e3 --- /dev/null +++ b/memory-profile-ecommerce.md @@ -0,0 +1,129 @@ +# AggOp Memory Profile: fraud-team + +## Workload Summary + +- Workload: `ecommerce` +- Events replayed per op: `2000` +- Derivations discovered: `1` +- Aggregate features discovered: `20` +- Per-entity structural estimate: `1333232` bytes + +## Sorted Op Table + +| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | +|------|----|-------|-------------|------------|-------------| +| 1 | `n_unique` | `windowed` | 80 | 1037960 | 1038040 | +| 2 | `top_k` | `windowed` | 80 | 202080 | 202160 | +| 3 | `quantile` | `windowed` | 80 | 84080 | 84160 | +| 4 | `entropy` | `windowed` | 80 | 6232 | 6312 | +| 5 | `bloom_member` | `lifetime` | 80 | 1280 | 1360 | +| 6 | `max` | `lifetime` | 240 | 0 | 240 | +| 7 | `mean` | `lifetime` | 240 | 0 | 240 | +| 8 | `min` | `lifetime` | 240 | 0 | 240 | +| 9 | `sum` | `lifetime` | 240 | 0 | 240 | +| 10 | `count` | `lifetime` | 80 | 0 | 80 | +| 11 | `std` | `lifetime` | 80 | 0 | 80 | +| 12 | `var` | `lifetime` | 80 | 0 | 80 | + +## Top 5 Offenders + +### 1. `TxnAgg` / `merchants_distinct_1h` / `n_unique` + +- Bytes: stack=80 heap=1037960 total=1038040 +- Shape: `windowed` (1h) +- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Breakdown rollup: + - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) +- Raw breakdown: + - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + +### 2. `TxnAgg` / `top_merchants_1h` / `top_k` + +- Bytes: stack=80 heap=202080 total=202160 +- Shape: `windowed` (1h) +- Recommendation: restructure only if lazy bucket materialization still dominates +- Breakdown rollup: + - `TopK exact BTreeMap entries across buckets`: 192000 bytes (BTreeMap, summed across active window buckets) + - `Box across buckets`: 5920 bytes (Box, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) +- Raw breakdown: + - `Windowed bucket 11 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 15 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 19 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 23 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 27 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 3 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 31 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 35 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + +### 3. `TxnAgg` / `amount_p99_1h` / `quantile` + +- Bytes: stack=80 heap=84080 total=84160 +- Shape: `windowed` (1h) +- Recommendation: restructure only if lazy bucket materialization still dominates +- Breakdown rollup: + - `Percentile exact samples across buckets`: 75776 bytes (Vec, summed across active window buckets) + - `Box across buckets`: 4144 bytes (Box, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) +- Raw breakdown: + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 1 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 10 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 11 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 12 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 13 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 14 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 15 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + +### 4. `TxnAgg` / `category_entropy_1h` / `entropy` + +- Bytes: stack=80 heap=6232 total=6312 +- Shape: `windowed` (1h) +- Recommendation: restructure only if lazy bucket materialization still dominates +- Breakdown rollup: + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 2072 bytes (Box, summed across active window buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) +- Raw breakdown: + - `WindowedOp spilled bucket SmallVec`: 1024 bytes (SmallVec, spilled capacity * size_of::<(i64, Box)>()) + - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 10 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 11 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 12 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 13 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + +### 5. `TxnAgg` / `device_seen` / `bloom_member` + +- Bytes: stack=80 heap=1280 total=1360 +- Shape: `lifetime` +- Recommendation: keep for now; quantify sparse-to-dense sketch options next +- Breakdown: + - `Bloom filter words`: 1232 bytes (Vec, capacity * size_of::() for bloom bit-array storage) + - `Box`: 48 bytes (Box, heap allocation for boxed Bloom wrapper) + +## Metrics Coherence + +- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes +- Profile per-entity estimate: `1333232` bytes +- Tolerance: `15.0%` +- Assertion: bytes_per_entity_p99 diverged by 1326232 bytes; file sibling work to replace the static placeholder with live sampling. + +## Notes + +- `stack_bytes` is the inline `AggOp` enum slot for each feature. +- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 0b47007c..49de252f 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -6,143 +6,182 @@ - Events replayed per op: `2000` - Derivations discovered: `9` - Aggregate features discovered: `111` -- Per-entity structural estimate: `405997` bytes +- Per-entity structural estimate: `3085692` bytes ## Sorted Op Table -| Rank | Op | Stack bytes | Heap bytes | Total bytes | -|------|----|-------------|------------|-------------| -| 1 | `n_unique` | 1200 | 299930 | 301130 | -| 2 | `count` | 1440 | 30864 | 32304 | -| 3 | `top_k` | 160 | 18366 | 18526 | -| 4 | `quantile` | 320 | 13481 | 13801 | -| 5 | `event_type_mix` | 80 | 9728 | 9808 | -| 6 | `sum` | 320 | 4576 | 4896 | -| 7 | `entropy` | 160 | 4308 | 4468 | -| 8 | `bloom_member` | 80 | 3308 | 3388 | -| 9 | `burst_count` | 240 | 3072 | 3312 | -| 10 | `distance_from_home` | 80 | 1720 | 1800 | -| 11 | `reservoir_sample` | 80 | 1600 | 1680 | -| 12 | `seasonal_deviation` | 80 | 1427 | 1507 | -| 13 | `dow_hour_histogram` | 80 | 1344 | 1424 | -| 14 | `geo_velocity` | 160 | 372 | 532 | -| 15 | `mean` | 80 | 416 | 496 | -| 16 | `min` | 80 | 416 | 496 | -| 17 | `std` | 80 | 416 | 496 | -| 18 | `var` | 80 | 416 | 496 | -| 19 | `first_seen` | 400 | 0 | 400 | -| 20 | `first_n` | 80 | 256 | 336 | -| 21 | `hour_of_day_histogram` | 80 | 255 | 335 | -| 22 | `geo_spread` | 80 | 251 | 331 | -| 23 | `age` | 320 | 0 | 320 | -| 24 | `negative_streak` | 320 | 0 | 320 | -| 25 | `geo_distance` | 80 | 171 | 251 | -| 26 | `last_n` | 80 | 160 | 240 | -| 27 | `last_seen` | 240 | 0 | 240 | -| 28 | `most_recent_n` | 80 | 160 | 240 | -| 29 | `time_since` | 240 | 0 | 240 | -| 30 | `decayed_count` | 160 | 0 | 160 | -| 31 | `first_seen_in_window` | 160 | 0 | 160 | -| 32 | `streak` | 160 | 0 | 160 | -| 33 | `lag` | 80 | 64 | 144 | -| 34 | `time_since_last_n` | 80 | 40 | 120 | -| 35 | `decayed_sum` | 80 | 0 | 80 | -| 36 | `delta_from_prev` | 80 | 0 | 80 | -| 37 | `ew_zscore` | 80 | 0 | 80 | -| 38 | `ewma` | 80 | 0 | 80 | -| 39 | `ewvar` | 80 | 0 | 80 | -| 40 | `first` | 80 | 0 | 80 | -| 41 | `has_seen` | 80 | 0 | 80 | -| 42 | `inter_arrival_stats` | 80 | 0 | 80 | -| 43 | `last` | 80 | 0 | 80 | -| 44 | `max` | 80 | 0 | 80 | -| 45 | `max_streak` | 80 | 0 | 80 | -| 46 | `outlier_count` | 80 | 0 | 80 | -| 47 | `rate_of_change` | 80 | 0 | 80 | -| 48 | `trend` | 80 | 0 | 80 | -| 49 | `trend_residual` | 80 | 0 | 80 | -| 50 | `twa` | 80 | 0 | 80 | -| 51 | `value_change_count` | 80 | 0 | 80 | -| 52 | `z_score` | 80 | 0 | 80 | +| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | +|------|----|-------|-------------|------------|-------------| +| 1 | `n_unique` | `windowed` | 1040 | 2712248 | 2713288 | +| 2 | `top_k` | `windowed` | 160 | 241768 | 241928 | +| 3 | `count` | `windowed` | 1200 | 30864 | 32064 | +| 4 | `entropy` | `windowed` | 80 | 30824 | 30904 | +| 5 | `quantile` | `windowed` | 320 | 28608 | 28928 | +| 6 | `event_type_mix` | `lifetime` | 80 | 9728 | 9808 | +| 7 | `sum` | `windowed` | 160 | 4576 | 4736 | +| 8 | `n_unique` | `lifetime` | 160 | 4304 | 4464 | +| 9 | `burst_count` | `windowed` | 240 | 3072 | 3312 | +| 10 | `distance_from_home` | `lifetime` | 80 | 1720 | 1800 | +| 11 | `reservoir_sample` | `lifetime` | 80 | 1600 | 1680 | +| 12 | `seasonal_deviation` | `lifetime` | 80 | 1427 | 1507 | +| 13 | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1424 | +| 14 | `bloom_member` | `lifetime` | 80 | 1280 | 1360 | +| 15 | `geo_velocity` | `lifetime` | 160 | 372 | 532 | +| 16 | `mean` | `windowed` | 80 | 416 | 496 | +| 17 | `min` | `windowed` | 80 | 416 | 496 | +| 18 | `std` | `windowed` | 80 | 416 | 496 | +| 19 | `var` | `windowed` | 80 | 416 | 496 | +| 20 | `first_seen` | `lifetime` | 400 | 0 | 400 | +| 21 | `first_n` | `lifetime` | 80 | 256 | 336 | +| 22 | `hour_of_day_histogram` | `lifetime` | 80 | 255 | 335 | +| 23 | `geo_spread` | `lifetime` | 80 | 251 | 331 | +| 24 | `age` | `lifetime` | 320 | 0 | 320 | +| 25 | `negative_streak` | `lifetime` | 320 | 0 | 320 | +| 26 | `geo_distance` | `lifetime` | 80 | 171 | 251 | +| 27 | `count` | `lifetime` | 240 | 0 | 240 | +| 28 | `last_n` | `lifetime` | 80 | 160 | 240 | +| 29 | `last_seen` | `lifetime` | 240 | 0 | 240 | +| 30 | `most_recent_n` | `lifetime` | 80 | 160 | 240 | +| 31 | `time_since` | `lifetime` | 240 | 0 | 240 | +| 32 | `decayed_count` | `lifetime` | 160 | 0 | 160 | +| 33 | `first_seen_in_window` | `windowed` | 160 | 0 | 160 | +| 34 | `streak` | `lifetime` | 160 | 0 | 160 | +| 35 | `sum` | `lifetime` | 160 | 0 | 160 | +| 36 | `lag` | `lifetime` | 80 | 64 | 144 | +| 37 | `entropy` | `lifetime` | 80 | 56 | 136 | +| 38 | `time_since_last_n` | `lifetime` | 80 | 40 | 120 | +| 39 | `decayed_sum` | `lifetime` | 80 | 0 | 80 | +| 40 | `delta_from_prev` | `lifetime` | 80 | 0 | 80 | +| 41 | `ew_zscore` | `lifetime` | 80 | 0 | 80 | +| 42 | `ewma` | `lifetime` | 80 | 0 | 80 | +| 43 | `ewvar` | `lifetime` | 80 | 0 | 80 | +| 44 | `first` | `lifetime` | 80 | 0 | 80 | +| 45 | `has_seen` | `lifetime` | 80 | 0 | 80 | +| 46 | `inter_arrival_stats` | `windowed` | 80 | 0 | 80 | +| 47 | `last` | `lifetime` | 80 | 0 | 80 | +| 48 | `max` | `lifetime` | 80 | 0 | 80 | +| 49 | `max_streak` | `lifetime` | 80 | 0 | 80 | +| 50 | `outlier_count` | `windowed` | 80 | 0 | 80 | +| 51 | `rate_of_change` | `windowed` | 80 | 0 | 80 | +| 52 | `trend` | `windowed` | 80 | 0 | 80 | +| 53 | `trend_residual` | `windowed` | 80 | 0 | 80 | +| 54 | `twa` | `windowed` | 80 | 0 | 80 | +| 55 | `value_change_count` | `windowed` | 80 | 0 | 80 | +| 56 | `z_score` | `windowed` | 80 | 0 | 80 | ## Top 5 Offenders ### 1. `LoginByUser` / `ips_distinct_login_1h` / `n_unique` -- Bytes: stack=80 heap=48449 total=48529 -- Recommendation: keep for now; quantify sparse-to-dense sketch options next -- Breakdown: - - `Windowed bucket 7 / CountDistinct owned internals`: 1228 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 31 / CountDistinct owned internals`: 1224 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 23 / CountDistinct owned internals`: 1221 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 3 / CountDistinct owned internals`: 1220 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 27 / CountDistinct owned internals`: 1219 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 19 / CountDistinct owned internals`: 1217 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 35 / CountDistinct owned internals`: 1214 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 15 / CountDistinct owned internals`: 1213 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) +- Bytes: stack=80 heap=1037960 total=1038040 +- Shape: `windowed` (1h) +- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Breakdown rollup: + - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) +- Raw breakdown: + - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) ### 2. `TxnByIp` / `cards_per_ip_1h` / `n_unique` -- Bytes: stack=80 heap=48397 total=48477 -- Recommendation: keep for now; quantify sparse-to-dense sketch options next -- Breakdown: - - `Windowed bucket 19 / CountDistinct owned internals`: 1221 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 27 / CountDistinct owned internals`: 1220 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 35 / CountDistinct owned internals`: 1219 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 11 / CountDistinct owned internals`: 1216 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 15 / CountDistinct owned internals`: 1215 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 3 / CountDistinct owned internals`: 1215 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 23 / CountDistinct owned internals`: 1209 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 31 / CountDistinct owned internals`: 1209 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - -### 3. `TxnByCard` / `merchants_per_card_24h` / `n_unique` - -- Bytes: stack=80 heap=24391 total=24471 -- Recommendation: keep for now; quantify sparse-to-dense sketch options next -- Breakdown: - - `Windowed bucket 1 / CountDistinct owned internals`: 10494 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 0 / CountDistinct owned internals`: 7188 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 2 / CountDistinct owned internals`: 6173 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) +- Bytes: stack=80 heap=1037960 total=1038040 +- Shape: `windowed` (1h) +- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Breakdown rollup: + - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) + - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) + - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) +- Raw breakdown: + - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + +### 3. `TxnByIp` / `ip_top_users` / `top_k` + +- Bytes: stack=80 heap=129320 total=129400 +- Shape: `windowed` (1d) +- Recommendation: restructure only if lazy bucket materialization still dominates +- Breakdown rollup: + - `TopK count-min counters across buckets`: 65536 bytes (Vec, summed across active window buckets) + - `TopK exact BTreeMap entries across buckets`: 62400 bytes (BTreeMap, summed across active window buckets) + - `Box across buckets`: 480 bytes (Box, summed across active window buckets) + - `TopK heap index map across buckets`: 392 bytes (AHashMap, summed across active window buckets) + - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `TopK heap entries across buckets`: 96 bytes (Vec, summed across active window buckets) +- Raw breakdown: + - `Windowed bucket 1 / TopK count-min counters`: 65536 bytes (Vec, capacity * size_of::() for count-min sketch counters) + - `Windowed bucket 0 / TopK exact BTreeMap entries`: 33600 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 2 / TopK exact BTreeMap entries`: 28800 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 1 / TopK heap index map`: 392 bytes (AHashMap, estimated slot cost for TopK heap-position side index) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed payload) - -### 4. `TxnByUser` / `merchants_distinct_24h` / `n_unique` - -- Bytes: stack=80 heap=24391 total=24471 -- Recommendation: keep for now; quantify sparse-to-dense sketch options next -- Breakdown: - - `Windowed bucket 1 / CountDistinct owned internals`: 10494 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 0 / CountDistinct owned internals`: 7188 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 2 / CountDistinct owned internals`: 6173 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) + - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 1 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 2 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + +### 4. `TxnByUser` / `top_merchants_24h` / `top_k` + +- Bytes: stack=80 heap=112448 total=112528 +- Shape: `windowed` (1d) +- Recommendation: restructure only if lazy bucket materialization still dominates +- Breakdown rollup: + - `TopK exact BTreeMap entries across buckets`: 111552 bytes (BTreeMap, summed across active window buckets) + - `Box across buckets`: 480 bytes (Box, summed across active window buckets) + - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) +- Raw breakdown: + - `Windowed bucket 1 / TopK exact BTreeMap entries`: 49152 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 0 / TopK exact BTreeMap entries`: 33600 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 2 / TopK exact BTreeMap entries`: 28800 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 1 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 2 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed payload) - -### 5. `TxnByDevice` / `cards_per_device_24h` / `n_unique` -- Bytes: stack=80 heap=22174 total=22254 -- Recommendation: keep for now; quantify sparse-to-dense sketch options next -- Breakdown: - - `Windowed bucket 1 / CountDistinct owned internals`: 8259 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 0 / CountDistinct owned internals`: 7205 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) - - `Windowed bucket 2 / CountDistinct owned internals`: 6174 bytes (estimate, deterministic serialized-size proxy for private sketch/container internals) +### 5. `LoginByUser` / `uas_distinct_login_24h` / `n_unique` + +- Bytes: stack=80 heap=86552 total=86632 +- Shape: `windowed` (1d) +- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Breakdown rollup: + - `CountDistinct hash-set slots across buckets`: 86016 bytes (HashSet, summed across active window buckets) + - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Box across buckets`: 120 bytes (Box, summed across active window buckets) +- Raw breakdown: + - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 2 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed payload) + - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) ## Metrics Coherence - `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile per-entity estimate: `405997` bytes +- Profile per-entity estimate: `3085692` bytes - Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 398997 bytes; file sibling work to replace the static placeholder with live sampling. +- Assertion: bytes_per_entity_p99 diverged by 3078692 bytes; file sibling work to replace the static placeholder with live sampling. ## Notes diff --git a/memory-profile-medium.md b/memory-profile-medium.md new file mode 100644 index 00000000..210671cc --- /dev/null +++ b/memory-profile-medium.md @@ -0,0 +1,68 @@ +# AggOp Memory Profile: fraud-team + +## Workload Summary + +- Workload: `medium` +- Events replayed per op: `2000` +- Derivations discovered: `1` +- Aggregate features discovered: `5` +- Per-entity structural estimate: `400` bytes + +## Sorted Op Table + +| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | +|------|----|-------|-------------|------------|-------------| +| 1 | `count` | `lifetime` | 80 | 0 | 80 | +| 2 | `max` | `lifetime` | 80 | 0 | 80 | +| 3 | `mean` | `lifetime` | 80 | 0 | 80 | +| 4 | `min` | `lifetime` | 80 | 0 | 80 | +| 5 | `sum` | `lifetime` | 80 | 0 | 80 | + +## Top 5 Offenders + +### 1. `TxnAgg` / `avg_amt` / `mean` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; scalar state spends only the shared AggOp slot +- Breakdown: + +### 2. `TxnAgg` / `cnt` / `count` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; scalar state spends only the shared AggOp slot +- Breakdown: + +### 3. `TxnAgg` / `max_amt` / `max` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; no targeted restructuring until workload ranking justifies it +- Breakdown: + +### 4. `TxnAgg` / `min_amt` / `min` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; no targeted restructuring until workload ranking justifies it +- Breakdown: + +### 5. `TxnAgg` / `sum_amt` / `sum` + +- Bytes: stack=80 heap=0 total=80 +- Shape: `lifetime` +- Recommendation: keep; scalar state spends only the shared AggOp slot +- Breakdown: + +## Metrics Coherence + +- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes +- Profile per-entity estimate: `400` bytes +- Tolerance: `15.0%` +- Assertion: bytes_per_entity_p99 diverged by 6600 bytes; file sibling work to replace the static placeholder with live sampling. + +## Notes + +- `stack_bytes` is the inline `AggOp` enum slot for each feature. +- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. From 2026c6a1fc76c886fb7d9df6189b4e2d03112be2 Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Sat, 16 May 2026 14:49:58 -0400 Subject: [PATCH 3/9] Profiler use event gen, full path AggOp profile --- crates/beava-bench/src/bin/memprofile.rs | 287 +++++++-- crates/beava-bench/tests/memprofile_smoke.rs | 13 + memory-profile-fraud-team.md | 589 ++++++++++++++++--- 3 files changed, 728 insertions(+), 161 deletions(-) diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs index c423b763..8346e086 100644 --- a/crates/beava-bench/src/bin/memprofile.rs +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -3,7 +3,7 @@ use anyhow::{anyhow, Context, Result}; use beava_core::agg_op::{AggExtParams, AggKind, AggOp, AggOpDescriptor, SketchParams}; use beava_core::mem_usage::{MemBreakdown, MemProfile, MemUsage}; -use beava_core::row::{Row, Value}; +use beava_core::row::{json_value_to_beava_value, Row}; use clap::Parser; use serde_json::Value as JsonValue; use std::collections::BTreeMap; @@ -27,17 +27,22 @@ struct Args { #[derive(Debug, Clone)] struct FeatureSpec { + source_events: Vec, derivation: String, feature: String, op_name: String, + key_path: Vec, desc: AggOpDescriptor, } #[derive(Debug, Clone)] struct ProfileRow { + source_events: Vec, derivation: String, feature: String, op_name: String, + key_path: Vec, + events_applied: u64, shape: ProfileShape, window_ms: Option, profile: MemProfile, @@ -64,11 +69,14 @@ struct OpTotal { op_name: String, shape: ProfileShape, profile: MemProfile, + rows: Vec, } struct ReportInput<'a> { workload: &'a str, - events: u64, + events_requested: u64, + events_generated: u64, + events_by_source: &'a BTreeMap, derivation_count: usize, feature_count: usize, rows: &'a [ProfileRow], @@ -78,6 +86,23 @@ struct ReportInput<'a> { tolerance: f64, } +struct ProfileSlot { + spec: FeatureSpec, + op: AggOp, + events_applied: u64, +} + +impl ProfileSlot { + fn matches_source(&self, event_name: &str) -> bool { + self.spec.source_events.is_empty() + || self + .spec + .source_events + .iter() + .any(|source| source == event_name) + } +} + fn main() -> Result<()> { let args = Args::parse(); let report = build_report(&args)?; @@ -90,25 +115,59 @@ fn build_report(args: &Args) -> Result { let workload = beava_bench::workloads::load_by_name(&args.workload) .with_context(|| format!("load workload {:?}", args.workload))?; let features = feature_specs_from_register(&workload.register_payload)?; - let mut rows = Vec::with_capacity(features.len()); - - for spec in &features { - let mut op = AggOp::new(&spec.desc); - let field = spec.desc.field.as_deref(); - for i in 0..args.events { - let row = synthetic_row(i); - op.update(&row, 1_000_000 + i as i64 * 1_000, field, true); + let feature_count = features.len(); + + let mut slots = features + .into_iter() + .map(|spec| ProfileSlot { + op: AggOp::new(&spec.desc), + spec, + events_applied: 0, + }) + .collect::>(); + + let mut events_generated = 0; + let mut events_by_source = BTreeMap::new(); + for (idx, event) in (workload.event_generator)(args.events).enumerate() { + events_generated += 1; + *events_by_source + .entry(event.event_name.clone()) + .or_insert(0) += 1; + let now_ms = event_time_ms(&event.fields).unwrap_or(1_000_000 + idx as i64 * 1_000); + let row = row_from_fields(event.fields); + for slot in slots + .iter_mut() + .filter(|slot| slot.matches_source(&event.event_name)) + { + let field = slot.spec.desc.field.as_deref(); + slot.op.update(&row, now_ms, field, true); + slot.events_applied += 1; } - let mut profile = op.mem_profile(); - profile.label = format!("{}::{} ({})", spec.derivation, spec.feature, spec.op_name); + } + + let mut rows = Vec::with_capacity(slots.len()); + for slot in slots { + let spec = slot.spec; + let mut profile = slot.op.mem_profile(); + profile.label = format!( + "{}::{}::{} ({})", + format_sources(&spec.source_events), + spec.derivation, + spec.feature, + spec.op_name + ); let shape = profile_shape(&spec.desc); + let recommendation = recommendation_for(&spec.op_name, shape, &profile); rows.push(ProfileRow { - derivation: spec.derivation.clone(), - feature: spec.feature.clone(), - op_name: spec.op_name.clone(), + source_events: spec.source_events, + derivation: spec.derivation, + feature: spec.feature, + op_name: spec.op_name, + key_path: spec.key_path, + events_applied: slot.events_applied, shape, window_ms: spec.desc.window_ms, - recommendation: recommendation_for(&spec.op_name, shape, &profile), + recommendation, profile, }); } @@ -120,26 +179,28 @@ fn build_report(args: &Args) -> Result { .then_with(|| a.profile.label.cmp(&b.profile.label)) }); - let mut grouped: BTreeMap<(String, ProfileShape), Vec> = BTreeMap::new(); + let mut grouped: BTreeMap<(String, ProfileShape), Vec> = BTreeMap::new(); for row in &rows { grouped .entry((row.op_name.clone(), row.shape)) .or_default() - .push(row.profile.clone()); + .push(row.clone()); } let mut op_totals: Vec = grouped .into_iter() - .map(|((op_name, shape), profiles)| { + .map(|((op_name, shape), mut rows)| { let mut total = MemProfile::new(op_name.clone(), 0); - for profile in profiles { - total.stack_bytes += profile.stack_bytes; - total.heap_bytes += profile.heap_bytes; - total.breakdown.extend(profile.breakdown); + for row in &rows { + total.stack_bytes += row.profile.stack_bytes; + total.heap_bytes += row.profile.heap_bytes; + total.breakdown.extend(row.profile.breakdown.clone()); } + rows.sort_by(compare_profile_rows); OpTotal { op_name, shape, profile: total, + rows, } }) .collect(); @@ -154,9 +215,11 @@ fn build_report(args: &Args) -> Result { let per_entity_total: usize = rows.iter().map(|r| r.profile.total_bytes()).sum(); Ok(render_markdown(ReportInput { workload: &args.workload, - events: args.events, + events_requested: args.events, + events_generated, + events_by_source: &events_by_source, derivation_count: workload.derivations.len(), - feature_count: features.len(), + feature_count, rows: &rows, op_totals: &op_totals, per_entity_total, @@ -170,7 +233,18 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push_str("# AggOp Memory Profile: fraud-team\n\n"); out.push_str("## Workload Summary\n\n"); out.push_str(&format!("- Workload: `{}`\n", input.workload)); - out.push_str(&format!("- Events replayed per op: `{}`\n", input.events)); + out.push_str(&format!( + "- Events requested from generator: `{}`\n", + input.events_requested + )); + out.push_str(&format!( + "- Events replayed from generator: `{}`\n", + input.events_generated + )); + out.push_str("- Events by source:\n"); + for (source, count) in input.events_by_source { + out.push_str(&format!(" - `{source}`: `{count}`\n")); + } out.push_str(&format!( "- Derivations discovered: `{}`\n", input.derivation_count @@ -199,15 +273,58 @@ fn render_markdown(input: ReportInput<'_>) -> String { )); } - out.push_str("\n## Top 5 Offenders\n\n"); + out.push_str("\n## Sorted Op Path Details\n\n"); + out.push_str("Rows with `0` events applied show constructor footprint only; the workload generator did not emit an event for that path's upstream source.\n\n"); + for (idx, total) in input.op_totals.iter().enumerate() { + out.push_str(&format!( + "### {}. `{}` / `{}` paths\n\n", + idx + 1, + total.op_name, + total.shape.as_str() + )); + out.push_str("| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % |\n"); + out.push_str("|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------|\n"); + for row in &total.rows { + out.push_str(&format!( + "| {} | `{}` | `{}` | `{}` | `{}` | {} | {} | {} | {} | {:.1}% |\n", + idx + 1, + format_sources(&row.source_events), + row.derivation, + row.feature, + format_key_path(&row.key_path), + row.events_applied, + row.profile.stack_bytes, + row.profile.heap_bytes, + row.profile.total_bytes(), + percent_of(row.profile.total_bytes(), total.profile.total_bytes()) + )); + } + out.push('\n'); + } + + out.push_str("## Top 5 Offenders\n\n"); for (idx, row) in input.rows.iter().take(5).enumerate() { out.push_str(&format!( - "### {}. `{}` / `{}` / `{}`\n\n", + "### {}. `{}` / `{}` / `{}` / `{}`\n\n", idx + 1, + format_sources(&row.source_events), row.derivation, row.feature, row.op_name )); + out.push_str(&format!( + "- Path: `{}` -> `{}` -> `{}` -> `{}` -> `{}`\n", + format_sources(&row.source_events), + row.derivation, + row.feature, + row.op_name, + row.shape.as_str() + )); + out.push_str(&format!( + "- Key path: `{}`\n", + format_key_path(&row.key_path) + )); + out.push_str(&format!("- Events applied: `{}`\n", row.events_applied)); out.push_str(&format!( "- Bytes: stack={} heap={} total={}\n", row.profile.stack_bytes, @@ -269,9 +386,34 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push_str("\n## Notes\n\n"); out.push_str("- `stack_bytes` is the inline `AggOp` enum slot for each feature.\n"); out.push_str("- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate.\n"); + out.push_str("- Path grain is `source_event -> derivation -> feature -> op -> shape`; path detail rows are children of the op/shape rollups above.\n"); out } +fn percent_of(part: usize, total: usize) -> f64 { + if total == 0 { + 0.0 + } else { + (part as f64 / total as f64) * 100.0 + } +} + +fn format_sources(sources: &[String]) -> String { + if sources.is_empty() { + "*".to_string() + } else { + sources.join("+") + } +} + +fn format_key_path(keys: &[String]) -> String { + if keys.is_empty() { + "-".to_string() + } else { + keys.join("+") + } +} + fn top_breakdown(entries: &[MemBreakdown], limit: usize) -> Vec { let mut entries = entries.to_vec(); entries.sort_by(|a, b| b.bytes.cmp(&a.bytes).then_with(|| a.label.cmp(&b.label))); @@ -279,6 +421,17 @@ fn top_breakdown(entries: &[MemBreakdown], limit: usize) -> Vec { entries } +fn compare_profile_rows(a: &ProfileRow, b: &ProfileRow) -> std::cmp::Ordering { + b.profile + .total_bytes() + .cmp(&a.profile.total_bytes()) + .then_with(|| b.events_applied.cmp(&a.events_applied)) + .then_with(|| format_sources(&a.source_events).cmp(&format_sources(&b.source_events))) + .then_with(|| a.derivation.cmp(&b.derivation)) + .then_with(|| a.feature.cmp(&b.feature)) + .then_with(|| a.op_name.cmp(&b.op_name)) +} + fn windowed_rollup(entries: &[MemBreakdown]) -> Vec { let mut grouped: BTreeMap = BTreeMap::new(); for entry in entries { @@ -387,6 +540,8 @@ fn feature_specs_from_register(register: &JsonValue) -> Result> .and_then(JsonValue::as_str) .unwrap_or("unknown_derivation") .to_string(); + let source_events = string_array_field(node, "upstreams"); + let table_key_path = string_array_field(node, "table_primary_key"); let Some(ops) = node.get("ops").and_then(JsonValue::as_array) else { continue; }; @@ -394,6 +549,11 @@ fn feature_specs_from_register(register: &JsonValue) -> Result> let Some(agg) = step.get("agg").and_then(JsonValue::as_object) else { continue; }; + let key_path = if table_key_path.is_empty() { + string_array_field(step, "keys") + } else { + table_key_path.clone() + }; for (feature, spec) in agg { let op_name = spec .get("op") @@ -402,10 +562,12 @@ fn feature_specs_from_register(register: &JsonValue) -> Result> .to_string(); let params = spec.get("params").unwrap_or(&JsonValue::Null); out.push(FeatureSpec { + source_events: source_events.clone(), derivation: derivation.clone(), feature: feature.clone(), desc: descriptor_from_op(&op_name, params)?, op_name, + key_path: key_path.clone(), }); } } @@ -509,42 +671,28 @@ fn agg_kind_from_name(name: &str) -> Result { Ok(kind) } -fn synthetic_row(i: u64) -> Row { - let key = format!("k{:08}", i % 100_000); - Row::new() - .with_field("event_time", Value::I64(1_000_000 + i as i64 * 1_000)) - .with_field("user_id", Value::Str(key.clone().into())) - .with_field("card_fp", Value::Str(format!("card{}", i % 2_048).into())) - .with_field("device_id", Value::Str(format!("dev{}", i % 4_096).into())) - .with_field( - "ip_address", - Value::Str(format!("10.0.{}.{}", (i / 255) % 255, i % 255).into()), - ) - .with_field("merchant_id", Value::Str(format!("m{}", i % 512).into())) - .with_field("mcc", Value::Str(format!("{}", 5000 + i % 120).into())) - .with_field("amount", Value::F64(((i % 10_000) as f64) / 3.0 + 1.0)) - .with_field( - "card_country", - Value::Str((if i % 3 == 0 { "US" } else { "CA" }).into()), - ) - .with_field( - "ip_country", - Value::Str((if i % 5 == 0 { "GB" } else { "US" }).into()), - ) - .with_field("billing_country", Value::Str("US".into())) - .with_field("lat", Value::F64(37.0 + (i % 100) as f64 * 0.001)) - .with_field("lon", Value::F64(-122.0 - (i % 100) as f64 * 0.001)) - .with_field("declined", Value::I64((i % 7 == 0) as i64)) - .with_field("success", Value::I64((i % 11 != 0) as i64)) - .with_field("is_chargeback", Value::I64((i % 13 == 0) as i64)) - .with_field("user_agent", Value::Str(format!("ua{}", i % 64).into())) - .with_field("email", Value::Str(format!("u{}@x.test", i % 2048).into())) - .with_field( - "email_domain", - Value::Str(format!("d{}.test", i % 64).into()), - ) - .with_field("ssn_hash", Value::Str(format!("ssn{}", i % 8192).into())) - .with_field("__expr", Value::Str(format!("cell{}", i % 4096).into())) +fn row_from_fields(fields: serde_json::Map) -> Row { + fields.into_iter().fold(Row::new(), |row, (field, value)| { + row.with_field(&field, json_value_to_beava_value(value)) + }) +} + +fn event_time_ms(fields: &serde_json::Map) -> Option { + fields.get("event_time").and_then(JsonValue::as_i64) +} + +fn string_array_field(value: &JsonValue, key: &str) -> Vec { + value + .get(key) + .and_then(JsonValue::as_array) + .map(|items| { + items + .iter() + .filter_map(JsonValue::as_str) + .map(str::to_string) + .collect() + }) + .unwrap_or_default() } fn string_param(params: &JsonValue, key: &str) -> Option { @@ -634,10 +782,21 @@ mod tests { }; let report = build_report(&args).unwrap(); assert!(report.contains("# AggOp Memory Profile: fraud-team")); + assert!(report.contains("Events requested from generator: `5`")); + assert!(report.contains("Events replayed from generator: `5`")); + assert!(report.contains(" - `Txn`: `5`")); + assert!(!report.contains("Events replayed per op")); assert!(report.contains("## Sorted Op Table")); + assert!(report.contains("## Sorted Op Path Details")); assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); assert!(report.contains("| Rank | Op | Shape |")); + assert!(report.contains( + "| Parent rank | Source event | Derivation | Feature | Key path | Events applied |" + )); + assert!(report + .contains("| `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 |")); + assert!(report.contains("- Events applied: `5`")); } } diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs index 1b26d8cb..130819fe 100644 --- a/crates/beava-bench/tests/memprofile_smoke.rs +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -20,11 +20,24 @@ fn memprofile_smoke_writes_required_sections() { let report = std::fs::read_to_string(output).expect("read report"); assert!(report.contains("# AggOp Memory Profile: fraud-team")); + assert!(report.contains("Events requested from generator: `50`")); + assert!(report.contains("Events replayed from generator: `50`")); + assert!(report.contains(" - `Txn`: `50`")); + assert!(!report.contains("Events replayed per op")); assert!(report.contains("## Sorted Op Table")); + assert!(report.contains("## Sorted Op Path Details")); assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); assert!(report.contains("| Rank | Op | Shape |")); + assert!(report.contains( + "| Parent rank | Source event | Derivation | Feature | Key path | Events applied |" + )); + assert!( + report.contains("| `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 |") + ); + assert!(report.contains("- Path: `Txn` ->")); + assert!(report.contains("- Events applied: `50`")); assert!(report.contains("`windowed`")); assert!(report.contains("`lifetime`")); assert!(report.contains("- Breakdown rollup:")); diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 49de252f..63414217 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -3,41 +3,44 @@ ## Workload Summary - Workload: `fraud` -- Events replayed per op: `2000` +- Events requested from generator: `2000` +- Events replayed from generator: `2000` +- Events by source: + - `Txn`: `2000` - Derivations discovered: `9` - Aggregate features discovered: `111` -- Per-entity structural estimate: `3085692` bytes +- Per-entity structural estimate: `474904` bytes ## Sorted Op Table | Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | |------|----|-------|-------------|------------|-------------| -| 1 | `n_unique` | `windowed` | 1040 | 2712248 | 2713288 | -| 2 | `top_k` | `windowed` | 160 | 241768 | 241928 | -| 3 | `count` | `windowed` | 1200 | 30864 | 32064 | -| 4 | `entropy` | `windowed` | 80 | 30824 | 30904 | -| 5 | `quantile` | `windowed` | 320 | 28608 | 28928 | -| 6 | `event_type_mix` | `lifetime` | 80 | 9728 | 9808 | -| 7 | `sum` | `windowed` | 160 | 4576 | 4736 | -| 8 | `n_unique` | `lifetime` | 160 | 4304 | 4464 | -| 9 | `burst_count` | `windowed` | 240 | 3072 | 3312 | -| 10 | `distance_from_home` | `lifetime` | 80 | 1720 | 1800 | -| 11 | `reservoir_sample` | `lifetime` | 80 | 1600 | 1680 | -| 12 | `seasonal_deviation` | `lifetime` | 80 | 1427 | 1507 | -| 13 | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1424 | -| 14 | `bloom_member` | `lifetime` | 80 | 1280 | 1360 | -| 15 | `geo_velocity` | `lifetime` | 160 | 372 | 532 | -| 16 | `mean` | `windowed` | 80 | 416 | 496 | -| 17 | `min` | `windowed` | 80 | 416 | 496 | -| 18 | `std` | `windowed` | 80 | 416 | 496 | -| 19 | `var` | `windowed` | 80 | 416 | 496 | -| 20 | `first_seen` | `lifetime` | 400 | 0 | 400 | -| 21 | `first_n` | `lifetime` | 80 | 256 | 336 | +| 1 | `n_unique` | `windowed` | 1040 | 187688 | 188728 | +| 2 | `top_k` | `windowed` | 160 | 149704 | 149864 | +| 3 | `entropy` | `windowed` | 80 | 72623 | 72703 | +| 4 | `event_type_mix` | `lifetime` | 80 | 20608 | 20688 | +| 5 | `quantile` | `windowed` | 320 | 17856 | 18176 | +| 6 | `count` | `windowed` | 1200 | 3440 | 4640 | +| 7 | `burst_count` | `windowed` | 240 | 3072 | 3312 | +| 8 | `distance_from_home` | `lifetime` | 80 | 1720 | 1800 | +| 9 | `reservoir_sample` | `lifetime` | 80 | 1600 | 1680 | +| 10 | `seasonal_deviation` | `lifetime` | 80 | 1427 | 1507 | +| 11 | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1424 | +| 12 | `bloom_member` | `lifetime` | 80 | 1280 | 1360 | +| 13 | `sum` | `windowed` | 160 | 512 | 672 | +| 14 | `geo_velocity` | `lifetime` | 160 | 357 | 517 | +| 15 | `n_unique` | `lifetime` | 160 | 336 | 496 | +| 16 | `first_seen` | `lifetime` | 400 | 0 | 400 | +| 17 | `first_n` | `lifetime` | 80 | 256 | 336 | +| 18 | `mean` | `windowed` | 80 | 256 | 336 | +| 19 | `min` | `windowed` | 80 | 256 | 336 | +| 20 | `std` | `windowed` | 80 | 256 | 336 | +| 21 | `var` | `windowed` | 80 | 256 | 336 | | 22 | `hour_of_day_histogram` | `lifetime` | 80 | 255 | 335 | -| 23 | `geo_spread` | `lifetime` | 80 | 251 | 331 | +| 23 | `geo_spread` | `lifetime` | 80 | 250 | 330 | | 24 | `age` | `lifetime` | 320 | 0 | 320 | | 25 | `negative_streak` | `lifetime` | 320 | 0 | 320 | -| 26 | `geo_distance` | `lifetime` | 80 | 171 | 251 | +| 26 | `geo_distance` | `lifetime` | 80 | 192 | 272 | | 27 | `count` | `lifetime` | 240 | 0 | 240 | | 28 | `last_n` | `lifetime` | 80 | 160 | 240 | | 29 | `last_seen` | `lifetime` | 240 | 0 | 240 | @@ -69,121 +72,513 @@ | 55 | `value_change_count` | `windowed` | 80 | 0 | 80 | | 56 | `z_score` | `windowed` | 80 | 0 | 80 | +## Sorted Op Path Details + +Rows with `0` events applied show constructor footprint only; the workload generator did not emit an event for that path's upstream source. + +### 1. `n_unique` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 1 | `Txn` | `TxnByCard` | `merchants_per_card_24h` | `card_fp` | 2000 | 80 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByDevice` | `cards_per_device_24h` | `device_id` | 2000 | 80 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByIp` | `cards_per_ip_1h` | `ip_address` | 2000 | 80 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByUser` | `countries_distinct_7d` | `user_id` | 2000 | 80 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByUser` | `ips_distinct_24h` | `user_id` | 2000 | 80 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByUser` | `merchants_distinct_24h` | `user_id` | 2000 | 80 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByDevice` | `users_per_device_24h` | `device_id` | 2000 | 80 | 4392 | 4472 | 2.4% | +| 1 | `Txn` | `TxnByIp` | `users_per_ip_24h` | `ip_address` | 2000 | 80 | 4392 | 4472 | 2.4% | +| 1 | `Txn` | `TxnByMerchant` | `users_per_merchant_24h` | `merchant_id` | 2000 | 80 | 4392 | 4472 | 2.4% | +| 1 | `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 | 80 | 176 | 256 | 0.1% | +| 1 | `Login` | `LoginByUser` | `uas_distinct_login_24h` | `user_id` | 0 | 80 | 176 | 256 | 0.1% | +| 1 | `Signup` | `SignupByIp` | `emails_per_ip_24h` | `ip_address` | 0 | 80 | 176 | 256 | 0.1% | +| 1 | `Signup` | `SignupByIp` | `ssn_reuse_per_ip_30d` | `ip_address` | 0 | 80 | 176 | 256 | 0.1% | + +### 2. `top_k` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 2 | `Txn` | `TxnByUser` | `top_merchants_24h` | `user_id` | 2000 | 80 | 83264 | 83344 | 55.6% | +| 2 | `Txn` | `TxnByIp` | `ip_top_users` | `ip_address` | 2000 | 80 | 66440 | 66520 | 44.4% | + +### 3. `entropy` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 3 | `Txn` | `TxnByUser` | `mcc_entropy_24h` | `user_id` | 2000 | 80 | 72623 | 72703 | 100.0% | + +### 4. `event_type_mix` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 4 | `Txn` | `TxnByUser` | `event_mix_24h` | `user_id` | 2000 | 80 | 20608 | 20688 | 100.0% | + +### 5. `quantile` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 5 | `Txn` | `TxnByMerchant` | `merchant_amount_p99_24h` | `merchant_id` | 2000 | 80 | 4464 | 4544 | 25.0% | +| 5 | `Txn` | `TxnByUser` | `amount_p95_24h` | `user_id` | 2000 | 80 | 4464 | 4544 | 25.0% | +| 5 | `Txn` | `TxnByUser` | `p50_amount_24h` | `user_id` | 2000 | 80 | 4464 | 4544 | 25.0% | +| 5 | `Txn` | `TxnByUser` | `p99_amount_24h` | `user_id` | 2000 | 80 | 4464 | 4544 | 25.0% | + +### 6. `count` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 6 | `Txn` | `TxnByCard` | `decline_count_1h` | `card_fp` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByCard` | `txn_per_card_1h` | `card_fp` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByCard` | `txn_per_card_24h` | `card_fp` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByDevice` | `device_txn_count_24h` | `device_id` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByIp` | `txn_per_ip_1h` | `ip_address` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByIp` | `txn_per_ip_24h` | `ip_address` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByMerchant` | `txn_per_merchant_24h` | `merchant_id` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByUser` | `txn_count_1h` | `user_id` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByUser` | `txn_count_24h` | `user_id` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByUser` | `txn_count_5m` | `user_id` | 2000 | 80 | 256 | 336 | 7.2% | +| 6 | `CardAdd` | `CardAddByDevice` | `card_add_per_device_24h` | `device_id` | 0 | 80 | 176 | 256 | 5.5% | +| 6 | `Login` | `LoginByUser` | `login_count_1h` | `user_id` | 0 | 80 | 176 | 256 | 5.5% | +| 6 | `Login` | `LoginByUser` | `login_count_24h` | `user_id` | 0 | 80 | 176 | 256 | 5.5% | +| 6 | `Refund` | `RefundByUser` | `refund_count_24h` | `user_id` | 0 | 80 | 176 | 256 | 5.5% | +| 6 | `Signup` | `SignupByIp` | `signup_per_ip_24h` | `ip_address` | 0 | 80 | 176 | 256 | 5.5% | + +### 7. `burst_count` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 7 | `Txn` | `TxnByCard` | `small_amt_burst_5m` | `card_fp` | 2000 | 80 | 1024 | 1104 | 33.3% | +| 7 | `Txn` | `TxnByUser` | `burst_count_5m` | `user_id` | 2000 | 80 | 1024 | 1104 | 33.3% | +| 7 | `Signup` | `SignupByIp` | `signup_burst_10m` | `ip_address` | 0 | 80 | 1024 | 1104 | 33.3% | + +### 8. `distance_from_home` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 8 | `Txn` | `TxnByUser` | `dist_from_home` | `user_id` | 2000 | 80 | 1720 | 1800 | 100.0% | + +### 9. `reservoir_sample` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 9 | `Txn` | `TxnByUser` | `reservoir_50` | `user_id` | 2000 | 80 | 1600 | 1680 | 100.0% | + +### 10. `seasonal_deviation` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 10 | `Txn` | `TxnByUser` | `seasonal_dev` | `user_id` | 2000 | 80 | 1427 | 1507 | 100.0% | + +### 11. `dow_hour_histogram` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 11 | `Txn` | `TxnByUser` | `dow_hour_hist_30d` | `user_id` | 2000 | 80 | 1344 | 1424 | 100.0% | + +### 12. `bloom_member` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 12 | `Txn` | `TxnByUser` | `device_seen` | `user_id` | 2000 | 80 | 1280 | 1360 | 100.0% | + +### 13. `sum` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 13 | `Txn` | `TxnByIp` | `amount_sum_per_ip_1h` | `ip_address` | 2000 | 80 | 256 | 336 | 50.0% | +| 13 | `Txn` | `TxnByUser` | `sum_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 50.0% | + +### 14. `geo_velocity` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 14 | `Txn` | `TxnByUser` | `geo_kmh` | `user_id` | 2000 | 80 | 206 | 286 | 55.3% | +| 14 | `Login` | `LoginByUser` | `login_geo_kmh` | `user_id` | 0 | 80 | 151 | 231 | 44.7% | + +### 15. `n_unique` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 15 | `Txn` | `TxnByUser` | `unique_cells_24h` | `user_id` | 2000 | 80 | 168 | 248 | 50.0% | +| 15 | `CardAdd` | `CardAddByDevice` | `cards_per_device_lifetime` | `device_id` | 0 | 80 | 168 | 248 | 50.0% | + +### 16. `first_seen` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 16 | `Txn` | `TxnByCard` | `card_first_seen` | `card_fp` | 2000 | 80 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByDevice` | `device_first_seen` | `device_id` | 2000 | 80 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByIp` | `ip_first_seen` | `ip_address` | 2000 | 80 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByMerchant` | `merchant_first_seen` | `merchant_id` | 2000 | 80 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByUser` | `first_seen` | `user_id` | 2000 | 80 | 0 | 80 | 20.0% | + +### 17. `first_n` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 17 | `Txn` | `TxnByUser` | `first_5_merchants` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | + +### 18. `mean` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 18 | `Txn` | `TxnByUser` | `avg_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | + +### 19. `min` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 19 | `Txn` | `TxnByUser` | `min_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | + +### 20. `std` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 20 | `Txn` | `TxnByUser` | `std_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | + +### 21. `var` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 21 | `Txn` | `TxnByUser` | `var_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | + +### 22. `hour_of_day_histogram` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 22 | `Txn` | `TxnByUser` | `hour_hist_30d` | `user_id` | 2000 | 80 | 255 | 335 | 100.0% | + +### 23. `geo_spread` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 23 | `Txn` | `TxnByUser` | `geo_spread_24h` | `user_id` | 2000 | 80 | 250 | 330 | 100.0% | + +### 24. `age` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 24 | `Txn` | `TxnByCard` | `card_age` | `card_fp` | 2000 | 80 | 0 | 80 | 25.0% | +| 24 | `Txn` | `TxnByDevice` | `device_age` | `device_id` | 2000 | 80 | 0 | 80 | 25.0% | +| 24 | `Txn` | `TxnByIp` | `ip_age` | `ip_address` | 2000 | 80 | 0 | 80 | 25.0% | +| 24 | `Txn` | `TxnByUser` | `age` | `user_id` | 2000 | 80 | 0 | 80 | 25.0% | + +### 25. `negative_streak` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 25 | `Txn` | `TxnByCard` | `decline_streak_card` | `card_fp` | 2000 | 80 | 0 | 80 | 25.0% | +| 25 | `Txn` | `TxnByUser` | `decline_streak` | `user_id` | 2000 | 80 | 0 | 80 | 25.0% | +| 25 | `CardAdd` | `CardAddByDevice` | `card_add_failure_streak` | `device_id` | 0 | 80 | 0 | 80 | 25.0% | +| 25 | `Login` | `LoginByUser` | `failed_login_streak` | `user_id` | 0 | 80 | 0 | 80 | 25.0% | + +### 26. `geo_distance` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 26 | `Txn` | `TxnByUser` | `geo_dist_last` | `user_id` | 2000 | 80 | 192 | 272 | 100.0% | + +### 27. `count` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 27 | `Txn` | `TxnByUser` | `txn_count_lifetime` | `user_id` | 2000 | 80 | 0 | 80 | 33.3% | +| 27 | `Refund` | `RefundByUser` | `chargeback_count_lifetime` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | +| 27 | `Refund` | `RefundByUser` | `refund_count_lifetime` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | + +### 28. `last_n` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 28 | `Txn` | `TxnByUser` | `last_5_amounts` | `user_id` | 2000 | 80 | 160 | 240 | 100.0% | + +### 29. `last_seen` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 29 | `Txn` | `TxnByDevice` | `device_last_seen` | `device_id` | 2000 | 80 | 0 | 80 | 33.3% | +| 29 | `Txn` | `TxnByUser` | `last_seen` | `user_id` | 2000 | 80 | 0 | 80 | 33.3% | +| 29 | `Login` | `LoginByUser` | `last_login_at` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | + +### 30. `most_recent_n` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 30 | `Txn` | `TxnByUser` | `recent_5_amts` | `user_id` | 2000 | 80 | 160 | 240 | 100.0% | + +### 31. `time_since` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 31 | `Txn` | `TxnByUser` | `time_since_last` | `user_id` | 2000 | 80 | 0 | 80 | 33.3% | +| 31 | `Login` | `LoginByUser` | `time_since_last_login` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | +| 31 | `Refund` | `RefundByUser` | `time_since_last_cb` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | + +### 32. `decayed_count` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 32 | `Txn` | `TxnByUser` | `txn_decayed_count_24h` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | +| 32 | `Refund` | `RefundByUser` | `chargeback_decayed_count` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | + +### 33. `first_seen_in_window` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 33 | `Txn` | `TxnByUser` | `first_in_24h` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | +| 33 | `Refund` | `RefundByUser` | `first_refund_in_30d` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | + +### 34. `streak` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 34 | `Txn` | `TxnByUser` | `txn_streak` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | +| 34 | `Refund` | `RefundByUser` | `cb_streak` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | + +### 35. `sum` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 35 | `Txn` | `TxnByUser` | `sum_amount_lifetime` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | +| 35 | `Refund` | `RefundByUser` | `refund_amount_lifetime` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | + +### 36. `lag` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 36 | `Txn` | `TxnByUser` | `amount_lag1` | `user_id` | 2000 | 80 | 64 | 144 | 100.0% | + +### 37. `entropy` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 37 | `Txn` | `TxnByUser` | `geo_entropy_24h` | `user_id` | 2000 | 80 | 56 | 136 | 100.0% | + +### 38. `time_since_last_n` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 38 | `Txn` | `TxnByUser` | `time_since_last_5` | `user_id` | 2000 | 80 | 40 | 120 | 100.0% | + +### 39. `decayed_sum` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 39 | `Txn` | `TxnByUser` | `amount_decayed_sum_24h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 40. `delta_from_prev` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 40 | `Txn` | `TxnByUser` | `amount_delta` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 41. `ew_zscore` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 41 | `Txn` | `TxnByUser` | `amount_ew_zscore` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 42. `ewma` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 42 | `Txn` | `TxnByUser` | `amount_ewma_1h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 43. `ewvar` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 43 | `Txn` | `TxnByUser` | `amount_ewvar_1h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 44. `first` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 44 | `Txn` | `TxnByUser` | `first_amount` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 45. `has_seen` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 45 | `Txn` | `TxnByUser` | `has_seen` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 46. `inter_arrival_stats` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 46 | `Txn` | `TxnByUser` | `inter_arrival_1h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 47. `last` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 47 | `Txn` | `TxnByUser` | `last_amount` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 48. `max` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 48 | `Txn` | `TxnByUser` | `max_amount_lifetime` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 49. `max_streak` / `lifetime` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 49 | `Txn` | `TxnByUser` | `max_streak` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 50. `outlier_count` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 50 | `Txn` | `TxnByUser` | `amount_outliers_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 51. `rate_of_change` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 51 | `Txn` | `TxnByUser` | `amount_rate_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 52. `trend` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 52 | `Txn` | `TxnByUser` | `amount_trend_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 53. `trend_residual` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 53 | `Txn` | `TxnByUser` | `amount_trend_resid_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 54. `twa` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 54 | `Txn` | `TxnByUser` | `amount_twa_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 55. `value_change_count` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 55 | `Txn` | `TxnByUser` | `device_change_count_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + +### 56. `z_score` / `windowed` paths + +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| +| 56 | `Txn` | `TxnByUser` | `amount_z_score` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | + ## Top 5 Offenders -### 1. `LoginByUser` / `ips_distinct_login_1h` / `n_unique` +### 1. `Txn` / `TxnByUser` / `top_merchants_24h` / `top_k` -- Bytes: stack=80 heap=1037960 total=1038040 -- Shape: `windowed` (1h) -- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Path: `Txn` -> `TxnByUser` -> `top_merchants_24h` -> `top_k` -> `windowed` +- Key path: `user_id` +- Events applied: `2000` +- Bytes: stack=80 heap=83264 total=83344 +- Shape: `windowed` (1d) +- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) + - `TopK exact BTreeMap entries across buckets`: 82848 bytes (BTreeMap, summed across active window buckets) + - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Box across buckets`: 160 bytes (Box, summed across active window buckets) + - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - Raw breakdown: - - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - -### 2. `TxnByIp` / `cards_per_ip_1h` / `n_unique` - -- Bytes: stack=80 heap=1037960 total=1038040 -- Shape: `windowed` (1h) -- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately + - `Windowed bucket 0 / TopK exact BTreeMap entries`: 82848 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + +### 2. `Txn` / `TxnByUser` / `mcc_entropy_24h` / `entropy` + +- Path: `Txn` -> `TxnByUser` -> `mcc_entropy_24h` -> `entropy` -> `windowed` +- Key path: `user_id` +- Events applied: `2000` +- Bytes: stack=80 heap=72623 total=72703 +- Shape: `windowed` (1d) +- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) + - `Entropy category map entries across buckets`: 68960 bytes (BTreeMap, summed across active window buckets) + - `Entropy category string capacity across buckets`: 3351 bytes (String, summed across active window buckets) + - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 56 bytes (Box, summed across active window buckets) - Raw breakdown: - - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - -### 3. `TxnByIp` / `ip_top_users` / `top_k` - -- Bytes: stack=80 heap=129320 total=129400 + - `Windowed bucket 0 / Entropy category map entries`: 68960 bytes (BTreeMap, estimated node overhead plus String/u64 category payloads) + - `Windowed bucket 0 / Entropy category string capacity`: 3351 bytes (String, sum of tracked category string capacities) + - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 0 / Box`: 56 bytes (Box, heap allocation for boxed Entropy wrapper) + +### 3. `Txn` / `TxnByIp` / `ip_top_users` / `top_k` + +- Path: `Txn` -> `TxnByIp` -> `ip_top_users` -> `top_k` -> `windowed` +- Key path: `ip_address` +- Events applied: `2000` +- Bytes: stack=80 heap=66440 total=66520 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - `TopK count-min counters across buckets`: 65536 bytes (Vec, summed across active window buckets) - - `TopK exact BTreeMap entries across buckets`: 62400 bytes (BTreeMap, summed across active window buckets) - - `Box across buckets`: 480 bytes (Box, summed across active window buckets) - `TopK heap index map across buckets`: 392 bytes (AHashMap, summed across active window buckets) - - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Box across buckets`: 160 bytes (Box, summed across active window buckets) - `TopK heap entries across buckets`: 96 bytes (Vec, summed across active window buckets) + - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - Raw breakdown: - - `Windowed bucket 1 / TopK count-min counters`: 65536 bytes (Vec, capacity * size_of::() for count-min sketch counters) - - `Windowed bucket 0 / TopK exact BTreeMap entries`: 33600 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 2 / TopK exact BTreeMap entries`: 28800 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 1 / TopK heap index map`: 392 bytes (AHashMap, estimated slot cost for TopK heap-position side index) + - `Windowed bucket 0 / TopK count-min counters`: 65536 bytes (Vec, capacity * size_of::() for count-min sketch counters) + - `Windowed bucket 0 / TopK heap index map`: 392 bytes (AHashMap, estimated slot cost for TopK heap-position side index) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - - `Windowed bucket 1 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - - `Windowed bucket 2 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 0 / TopK heap entries`: 96 bytes (Vec, capacity * size_of::<(u64, TopKValue)>() for bounded top-k heap entries) + - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) -### 4. `TxnByUser` / `top_merchants_24h` / `top_k` +### 4. `Txn` / `TxnByCard` / `merchants_per_card_24h` / `n_unique` -- Bytes: stack=80 heap=112448 total=112528 +- Path: `Txn` -> `TxnByCard` -> `merchants_per_card_24h` -> `n_unique` -> `windowed` +- Key path: `card_fp` +- Events applied: `2000` +- Bytes: stack=80 heap=28968 total=29048 - Shape: `windowed` (1d) -- Recommendation: restructure only if lazy bucket materialization still dominates +- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately - Breakdown rollup: - - `TopK exact BTreeMap entries across buckets`: 111552 bytes (BTreeMap, summed across active window buckets) - - `Box across buckets`: 480 bytes (Box, summed across active window buckets) - - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `CountDistinct hash-set slots across buckets`: 28672 bytes (HashSet, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 40 bytes (Box, summed across active window buckets) - Raw breakdown: - - `Windowed bucket 1 / TopK exact BTreeMap entries`: 49152 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 0 / TopK exact BTreeMap entries`: 33600 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 2 / TopK exact BTreeMap entries`: 28800 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - - `Windowed bucket 1 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - - `Windowed bucket 2 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) -### 5. `LoginByUser` / `uas_distinct_login_24h` / `n_unique` +### 5. `Txn` / `TxnByDevice` / `cards_per_device_24h` / `n_unique` -- Bytes: stack=80 heap=86552 total=86632 +- Path: `Txn` -> `TxnByDevice` -> `cards_per_device_24h` -> `n_unique` -> `windowed` +- Key path: `device_id` +- Events applied: `2000` +- Bytes: stack=80 heap=28968 total=29048 - Shape: `windowed` (1d) - Recommendation: keep for now; quantify sketch precision and window bucket fanout separately - Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 86016 bytes (HashSet, summed across active window buckets) - - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `CountDistinct hash-set slots across buckets`: 28672 bytes (HashSet, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 120 bytes (Box, summed across active window buckets) + - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 40 bytes (Box, summed across active window buckets) - Raw breakdown: - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 2 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) ## Metrics Coherence - `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile per-entity estimate: `3085692` bytes +- Profile per-entity estimate: `474904` bytes - Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 3078692 bytes; file sibling work to replace the static placeholder with live sampling. +- Assertion: bytes_per_entity_p99 diverged by 467904 bytes; file sibling work to replace the static placeholder with live sampling. ## Notes - `stack_bytes` is the inline `AggOp` enum slot for each feature. - Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. +- Path grain is `source_event -> derivation -> feature -> op -> shape`; path detail rows are children of the op/shape rollups above. From a89c13b3401b07f9f5dbdfe4af7c1092a414ebcc Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Sat, 16 May 2026 16:24:17 -0400 Subject: [PATCH 4/9] More detailed AggOp profiling --- crates/beava-bench/src/bin/memprofile.rs | 29 +- crates/beava-bench/tests/memprofile_smoke.rs | 13 +- crates/beava-core/src/mem_usage.rs | 128 ++++- memory-profile-fraud-team.md | 575 ++++++++++--------- 4 files changed, 449 insertions(+), 296 deletions(-) diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs index 8346e086..44854c8e 100644 --- a/crates/beava-bench/src/bin/memprofile.rs +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -192,6 +192,9 @@ fn build_report(args: &Args) -> Result { let mut total = MemProfile::new(op_name.clone(), 0); for row in &rows { total.stack_bytes += row.profile.stack_bytes; + total.enum_slot_bytes += row.profile.enum_slot_bytes; + total.payload_bytes += row.profile.payload_bytes; + total.slack_bytes += row.profile.slack_bytes; total.heap_bytes += row.profile.heap_bytes; total.breakdown.extend(row.profile.breakdown.clone()); } @@ -259,15 +262,18 @@ fn render_markdown(input: ReportInput<'_>) -> String { )); out.push_str("## Sorted Op Table\n\n"); - out.push_str("| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes |\n"); - out.push_str("|------|----|-------|-------------|------------|-------------|\n"); + out.push_str("| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes |\n"); + out.push_str("|------|----|-------|-------------|-----------------|---------------|-------------|------------|-------------|\n"); for (idx, profile) in input.op_totals.iter().enumerate() { out.push_str(&format!( - "| {} | `{}` | `{}` | {} | {} | {} |\n", + "| {} | `{}` | `{}` | {} | {} | {} | {} | {} | {} |\n", idx + 1, profile.op_name, profile.shape.as_str(), profile.profile.stack_bytes, + profile.profile.enum_slot_bytes, + profile.profile.payload_bytes, + profile.profile.slack_bytes, profile.profile.heap_bytes, profile.profile.total_bytes() )); @@ -282,11 +288,11 @@ fn render_markdown(input: ReportInput<'_>) -> String { total.op_name, total.shape.as_str() )); - out.push_str("| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % |\n"); - out.push_str("|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------|\n"); + out.push_str("| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % |\n"); + out.push_str("|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------|\n"); for row in &total.rows { out.push_str(&format!( - "| {} | `{}` | `{}` | `{}` | `{}` | {} | {} | {} | {} | {:.1}% |\n", + "| {} | `{}` | `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} | {:.1}% |\n", idx + 1, format_sources(&row.source_events), row.derivation, @@ -294,6 +300,9 @@ fn render_markdown(input: ReportInput<'_>) -> String { format_key_path(&row.key_path), row.events_applied, row.profile.stack_bytes, + row.profile.enum_slot_bytes, + row.profile.payload_bytes, + row.profile.slack_bytes, row.profile.heap_bytes, row.profile.total_bytes(), percent_of(row.profile.total_bytes(), total.profile.total_bytes()) @@ -326,8 +335,11 @@ fn render_markdown(input: ReportInput<'_>) -> String { )); out.push_str(&format!("- Events applied: `{}`\n", row.events_applied)); out.push_str(&format!( - "- Bytes: stack={} heap={} total={}\n", + "- Bytes: stack={} (enum_slot_bytes={} payload_bytes={} slack_bytes={}) heap={} total={}\n", row.profile.stack_bytes, + row.profile.enum_slot_bytes, + row.profile.payload_bytes, + row.profile.slack_bytes, row.profile.heap_bytes, row.profile.total_bytes() )); @@ -385,6 +397,9 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push_str("\n## Notes\n\n"); out.push_str("- `stack_bytes` is the inline `AggOp` enum slot for each feature.\n"); + out.push_str("- `enum_slot_bytes` is the fixed-size `AggOp` enum slot charged to a row; parent rows sum this across child paths.\n"); + out.push_str("- `payload_bytes` is the active variant payload inside the enum slot. For boxed variants this is the inline `Box` pointer, while the boxed pointee remains in `heap_bytes`.\n"); + out.push_str("- `slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot: `enum_slot_bytes - payload_bytes`.\n"); out.push_str("- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate.\n"); out.push_str("- Path grain is `source_event -> derivation -> feature -> op -> shape`; path detail rows are children of the op/shape rollups above.\n"); out diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs index 130819fe..78b59be1 100644 --- a/crates/beava-bench/tests/memprofile_smoke.rs +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -29,18 +29,27 @@ fn memprofile_smoke_writes_required_sections() { assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); - assert!(report.contains("| Rank | Op | Shape |")); + assert!(report.contains("| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes |")); + assert!(report.contains("enum_slot_bytes")); + assert!(report.contains("payload_bytes")); + assert!(report.contains("slack_bytes")); assert!(report.contains( - "| Parent rank | Source event | Derivation | Feature | Key path | Events applied |" + "| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes |" + )); + assert!(report.contains( + "| `Txn` | `TxnByUser` | `txn_count_lifetime` | `user_id` | 50 | 80 | 80 | 8 | 72 | 0 | 80 |" )); assert!( report.contains("| `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 |") ); assert!(report.contains("- Path: `Txn` ->")); assert!(report.contains("- Events applied: `50`")); + assert!(report.contains("stack=80 (enum_slot_bytes=80 payload_bytes=")); assert!(report.contains("`windowed`")); assert!(report.contains("`lifetime`")); assert!(report.contains("- Breakdown rollup:")); assert!(report.contains("Windowed wrapper overhead")); + assert!(report.contains("`slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot")); assert!(!report.contains("CountDistinct owned internals")); + assert!(!report.contains("enum overhead")); } diff --git a/crates/beava-core/src/mem_usage.rs b/crates/beava-core/src/mem_usage.rs index c24c35eb..66c4a62b 100644 --- a/crates/beava-core/src/mem_usage.rs +++ b/crates/beava-core/src/mem_usage.rs @@ -31,6 +31,9 @@ pub struct MemBreakdown { pub struct MemProfile { pub label: String, pub stack_bytes: usize, + pub enum_slot_bytes: usize, + pub payload_bytes: usize, + pub slack_bytes: usize, pub heap_bytes: usize, pub breakdown: Vec, } @@ -40,11 +43,22 @@ impl MemProfile { Self { label: label.into(), stack_bytes, + enum_slot_bytes: stack_bytes, + payload_bytes: stack_bytes, + slack_bytes: 0, heap_bytes: 0, breakdown: Vec::new(), } } + pub fn with_stack_composition(mut self, enum_slot_bytes: usize, payload_bytes: usize) -> Self { + self.stack_bytes = enum_slot_bytes; + self.enum_slot_bytes = enum_slot_bytes; + self.payload_bytes = payload_bytes; + self.slack_bytes = enum_slot_bytes.saturating_sub(payload_bytes); + self + } + pub fn total_bytes(&self) -> usize { self.stack_bytes + self.heap_bytes } @@ -306,7 +320,9 @@ fn add_entropy_breakdown(profile: &mut MemProfile, state: &EntropyStateWrap) { impl MemUsage for AggOp { fn mem_profile(&self) -> MemProfile { - let mut profile = MemProfile::new(aggop_label(self), size_of::()); + let enum_slot_bytes = size_of::(); + let mut profile = MemProfile::new(aggop_label(self), enum_slot_bytes) + .with_stack_composition(enum_slot_bytes, aggop_payload_bytes(self)); match self { AggOp::Count(_) | AggOp::Sum(_) @@ -484,6 +500,66 @@ impl MemUsage for AggOp { } } +fn aggop_payload_bytes(op: &AggOp) -> usize { + match op { + AggOp::Count(s) => size_of_val(s), + AggOp::Sum(s) => size_of_val(s), + AggOp::Avg(s) => size_of_val(s), + AggOp::Min(s) => size_of_val(s), + AggOp::Max(s) => size_of_val(s), + AggOp::Variance(s) => size_of_val(s), + AggOp::StdDev(s) => size_of_val(s), + AggOp::Ratio(s) => size_of_val(s), + AggOp::CountDistinct(s) => size_of_val(s), + AggOp::Percentile(s) => size_of_val(s), + AggOp::TopK(s) => size_of_val(s), + AggOp::BloomMember(s) => size_of_val(s), + AggOp::Entropy(s) => size_of_val(s), + AggOp::Windowed(s) => size_of_val(s), + AggOp::First(s) => size_of_val(s), + AggOp::Last(s) => size_of_val(s), + AggOp::FirstN(s) => size_of_val(s), + AggOp::LastN(s) => size_of_val(s), + AggOp::Lag(s) => size_of_val(s), + AggOp::FirstSeen(s) => size_of_val(s), + AggOp::LastSeen(s) => size_of_val(s), + AggOp::Age(s) => size_of_val(s), + AggOp::HasSeen(s) => size_of_val(s), + AggOp::TimeSince(s) => size_of_val(s), + AggOp::TimeSinceLastN(s) => size_of_val(s), + AggOp::Streak(s) => size_of_val(s), + AggOp::MaxStreak(s) => size_of_val(s), + AggOp::NegativeStreak(s) => size_of_val(s), + AggOp::FirstSeenInWindow(s) => size_of_val(s), + AggOp::Ewma(s) => size_of_val(s), + AggOp::EwVar(s) => size_of_val(s), + AggOp::EwZScore(s) => size_of_val(s), + AggOp::DecayedSum(s) => size_of_val(s), + AggOp::DecayedCount(s) => size_of_val(s), + AggOp::Twa(s) => size_of_val(s), + AggOp::RateOfChange(s) => size_of_val(s), + AggOp::InterArrivalStats(s) => size_of_val(s), + AggOp::BurstCount(s) => size_of_val(s), + AggOp::DeltaFromPrev(s) => size_of_val(s), + AggOp::Trend(s) => size_of_val(s), + AggOp::TrendResidual(s) => size_of_val(s), + AggOp::OutlierCount(s) => size_of_val(s), + AggOp::ValueChangeCount(s) => size_of_val(s), + AggOp::ZScore(s) => size_of_val(s), + AggOp::Histogram(s) => size_of_val(s), + AggOp::HourOfDayHistogram(s) => size_of_val(s), + AggOp::DowHourHistogram(s) => size_of_val(s), + AggOp::SeasonalDeviation(s) => size_of_val(s), + AggOp::EventTypeMix(s) => size_of_val(s), + AggOp::MostRecentN(s) => size_of_val(s), + AggOp::ReservoirSample(s) => size_of_val(s), + AggOp::GeoVelocity(s) => size_of_val(s), + AggOp::GeoDistance(s) => size_of_val(s), + AggOp::GeoSpread(s) => size_of_val(s), + AggOp::DistanceFromHome(s) => size_of_val(s), + } +} + fn add_boxed_serialized(profile: &mut MemProfile, label: &str, value: &T) { profile.add_breakdown( format!("Box<{label}>"), @@ -564,6 +640,8 @@ fn aggop_label(op: &AggOp) -> String { mod tests { use super::*; use crate::agg_op::{AggKind, AggOp, AggOpDescriptor}; + use crate::agg_state::{CountDistinctStateWrap, CountState, SumState}; + use crate::agg_state_velocity::TrendResidualState; use crate::row::{Row, Value}; #[test] @@ -580,6 +658,54 @@ mod tests { assert_eq!(profile.stack_bytes, size_of::()); } + #[test] + fn mem_usage_stack_composition_tracks_payload_and_slack() { + let profile = MemProfile::new("sample", 80).with_stack_composition(80, 8); + assert_eq!(profile.stack_bytes, 80); + assert_eq!(profile.enum_slot_bytes, 80); + assert_eq!(profile.payload_bytes, 8); + assert_eq!(profile.slack_bytes, 72); + assert_eq!(profile.total_bytes(), 80); + } + + #[test] + fn mem_usage_aggop_payload_size_uses_active_variant_payload() { + let count = AggOp::Count(CountState::default()).mem_profile(); + assert_eq!(count.stack_bytes, size_of::()); + assert_eq!(count.enum_slot_bytes, size_of::()); + assert_eq!(count.payload_bytes, size_of::()); + assert_eq!( + count.slack_bytes, + size_of::() - size_of::() + ); + + let sum = AggOp::Sum(SumState::default()).mem_profile(); + assert_eq!(sum.payload_bytes, size_of::()); + assert!(sum.slack_bytes > 0); + + let trend_residual = AggOp::TrendResidual(TrendResidualState::default()).mem_profile(); + assert_eq!( + trend_residual.payload_bytes, + size_of::() + ); + } + + #[test] + fn mem_usage_boxed_aggop_payload_is_pointer_not_pointee() { + let profile = + AggOp::CountDistinct(Box::new(CountDistinctStateWrap::default())).mem_profile(); + assert_eq!(profile.stack_bytes, size_of::()); + assert_eq!( + profile.payload_bytes, + size_of::>() + ); + assert!(profile.slack_bytes > 0); + assert!(profile + .breakdown + .iter() + .any(|b| b.label == "Box")); + } + #[test] fn mem_usage_boxed_sketch_reports_box_breakdown() { let profile = AggOp::new(&AggOpDescriptor { diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 63414217..054ff852 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -13,64 +13,64 @@ ## Sorted Op Table -| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | -|------|----|-------|-------------|------------|-------------| -| 1 | `n_unique` | `windowed` | 1040 | 187688 | 188728 | -| 2 | `top_k` | `windowed` | 160 | 149704 | 149864 | -| 3 | `entropy` | `windowed` | 80 | 72623 | 72703 | -| 4 | `event_type_mix` | `lifetime` | 80 | 20608 | 20688 | -| 5 | `quantile` | `windowed` | 320 | 17856 | 18176 | -| 6 | `count` | `windowed` | 1200 | 3440 | 4640 | -| 7 | `burst_count` | `windowed` | 240 | 3072 | 3312 | -| 8 | `distance_from_home` | `lifetime` | 80 | 1720 | 1800 | -| 9 | `reservoir_sample` | `lifetime` | 80 | 1600 | 1680 | -| 10 | `seasonal_deviation` | `lifetime` | 80 | 1427 | 1507 | -| 11 | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1424 | -| 12 | `bloom_member` | `lifetime` | 80 | 1280 | 1360 | -| 13 | `sum` | `windowed` | 160 | 512 | 672 | -| 14 | `geo_velocity` | `lifetime` | 160 | 357 | 517 | -| 15 | `n_unique` | `lifetime` | 160 | 336 | 496 | -| 16 | `first_seen` | `lifetime` | 400 | 0 | 400 | -| 17 | `first_n` | `lifetime` | 80 | 256 | 336 | -| 18 | `mean` | `windowed` | 80 | 256 | 336 | -| 19 | `min` | `windowed` | 80 | 256 | 336 | -| 20 | `std` | `windowed` | 80 | 256 | 336 | -| 21 | `var` | `windowed` | 80 | 256 | 336 | -| 22 | `hour_of_day_histogram` | `lifetime` | 80 | 255 | 335 | -| 23 | `geo_spread` | `lifetime` | 80 | 250 | 330 | -| 24 | `age` | `lifetime` | 320 | 0 | 320 | -| 25 | `negative_streak` | `lifetime` | 320 | 0 | 320 | -| 26 | `geo_distance` | `lifetime` | 80 | 192 | 272 | -| 27 | `count` | `lifetime` | 240 | 0 | 240 | -| 28 | `last_n` | `lifetime` | 80 | 160 | 240 | -| 29 | `last_seen` | `lifetime` | 240 | 0 | 240 | -| 30 | `most_recent_n` | `lifetime` | 80 | 160 | 240 | -| 31 | `time_since` | `lifetime` | 240 | 0 | 240 | -| 32 | `decayed_count` | `lifetime` | 160 | 0 | 160 | -| 33 | `first_seen_in_window` | `windowed` | 160 | 0 | 160 | -| 34 | `streak` | `lifetime` | 160 | 0 | 160 | -| 35 | `sum` | `lifetime` | 160 | 0 | 160 | -| 36 | `lag` | `lifetime` | 80 | 64 | 144 | -| 37 | `entropy` | `lifetime` | 80 | 56 | 136 | -| 38 | `time_since_last_n` | `lifetime` | 80 | 40 | 120 | -| 39 | `decayed_sum` | `lifetime` | 80 | 0 | 80 | -| 40 | `delta_from_prev` | `lifetime` | 80 | 0 | 80 | -| 41 | `ew_zscore` | `lifetime` | 80 | 0 | 80 | -| 42 | `ewma` | `lifetime` | 80 | 0 | 80 | -| 43 | `ewvar` | `lifetime` | 80 | 0 | 80 | -| 44 | `first` | `lifetime` | 80 | 0 | 80 | -| 45 | `has_seen` | `lifetime` | 80 | 0 | 80 | -| 46 | `inter_arrival_stats` | `windowed` | 80 | 0 | 80 | -| 47 | `last` | `lifetime` | 80 | 0 | 80 | -| 48 | `max` | `lifetime` | 80 | 0 | 80 | -| 49 | `max_streak` | `lifetime` | 80 | 0 | 80 | -| 50 | `outlier_count` | `windowed` | 80 | 0 | 80 | -| 51 | `rate_of_change` | `windowed` | 80 | 0 | 80 | -| 52 | `trend` | `windowed` | 80 | 0 | 80 | -| 53 | `trend_residual` | `windowed` | 80 | 0 | 80 | -| 54 | `twa` | `windowed` | 80 | 0 | 80 | -| 55 | `value_change_count` | `windowed` | 80 | 0 | 80 | -| 56 | `z_score` | `windowed` | 80 | 0 | 80 | +| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | +|------|----|-------|-------------|-----------------|---------------|-------------|------------|-------------| +| 1 | `n_unique` | `windowed` | 1040 | 1040 | 104 | 936 | 187688 | 188728 | +| 2 | `top_k` | `windowed` | 160 | 160 | 16 | 144 | 149704 | 149864 | +| 3 | `entropy` | `windowed` | 80 | 80 | 8 | 72 | 72623 | 72703 | +| 4 | `event_type_mix` | `lifetime` | 80 | 80 | 8 | 72 | 20608 | 20688 | +| 5 | `quantile` | `windowed` | 320 | 320 | 32 | 288 | 17856 | 18176 | +| 6 | `count` | `windowed` | 1200 | 1200 | 120 | 1080 | 3440 | 4640 | +| 7 | `burst_count` | `windowed` | 240 | 240 | 216 | 24 | 3072 | 3312 | +| 8 | `distance_from_home` | `lifetime` | 80 | 80 | 8 | 72 | 1720 | 1800 | +| 9 | `reservoir_sample` | `lifetime` | 80 | 80 | 40 | 40 | 1600 | 1680 | +| 10 | `seasonal_deviation` | `lifetime` | 80 | 80 | 8 | 72 | 1427 | 1507 | +| 11 | `dow_hour_histogram` | `lifetime` | 80 | 80 | 24 | 56 | 1344 | 1424 | +| 12 | `bloom_member` | `lifetime` | 80 | 80 | 8 | 72 | 1280 | 1360 | +| 13 | `sum` | `windowed` | 160 | 160 | 16 | 144 | 512 | 672 | +| 14 | `geo_velocity` | `lifetime` | 160 | 160 | 16 | 144 | 357 | 517 | +| 15 | `n_unique` | `lifetime` | 160 | 160 | 16 | 144 | 336 | 496 | +| 16 | `first_seen` | `lifetime` | 400 | 400 | 160 | 240 | 0 | 400 | +| 17 | `first_n` | `lifetime` | 80 | 80 | 32 | 48 | 256 | 336 | +| 18 | `mean` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | +| 19 | `min` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | +| 20 | `std` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | +| 21 | `var` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | +| 22 | `hour_of_day_histogram` | `lifetime` | 80 | 80 | 8 | 72 | 255 | 335 | +| 23 | `geo_spread` | `lifetime` | 80 | 80 | 8 | 72 | 250 | 330 | +| 24 | `age` | `lifetime` | 320 | 320 | 128 | 192 | 0 | 320 | +| 25 | `negative_streak` | `lifetime` | 320 | 320 | 32 | 288 | 0 | 320 | +| 26 | `geo_distance` | `lifetime` | 80 | 80 | 8 | 72 | 192 | 272 | +| 27 | `count` | `lifetime` | 240 | 240 | 24 | 216 | 0 | 240 | +| 28 | `last_n` | `lifetime` | 80 | 80 | 40 | 40 | 160 | 240 | +| 29 | `last_seen` | `lifetime` | 240 | 240 | 96 | 144 | 0 | 240 | +| 30 | `most_recent_n` | `lifetime` | 80 | 80 | 48 | 32 | 160 | 240 | +| 31 | `time_since` | `lifetime` | 240 | 240 | 96 | 144 | 0 | 240 | +| 32 | `decayed_count` | `lifetime` | 160 | 160 | 64 | 96 | 0 | 160 | +| 33 | `first_seen_in_window` | `windowed` | 160 | 160 | 48 | 112 | 0 | 160 | +| 34 | `streak` | `lifetime` | 160 | 160 | 32 | 128 | 0 | 160 | +| 35 | `sum` | `lifetime` | 160 | 160 | 32 | 128 | 0 | 160 | +| 36 | `lag` | `lifetime` | 80 | 80 | 40 | 40 | 64 | 144 | +| 37 | `entropy` | `lifetime` | 80 | 80 | 8 | 72 | 56 | 136 | +| 38 | `time_since_last_n` | `lifetime` | 80 | 80 | 40 | 40 | 40 | 120 | +| 39 | `decayed_sum` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | +| 40 | `delta_from_prev` | `lifetime` | 80 | 80 | 24 | 56 | 0 | 80 | +| 41 | `ew_zscore` | `lifetime` | 80 | 80 | 48 | 32 | 0 | 80 | +| 42 | `ewma` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | +| 43 | `ewvar` | `lifetime` | 80 | 80 | 48 | 32 | 0 | 80 | +| 44 | `first` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | +| 45 | `has_seen` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | +| 46 | `inter_arrival_stats` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | +| 47 | `last` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | +| 48 | `max` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | +| 49 | `max_streak` | `lifetime` | 80 | 80 | 16 | 64 | 0 | 80 | +| 50 | `outlier_count` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | +| 51 | `rate_of_change` | `windowed` | 80 | 80 | 32 | 48 | 0 | 80 | +| 52 | `trend` | `windowed` | 80 | 80 | 48 | 32 | 0 | 80 | +| 53 | `trend_residual` | `windowed` | 80 | 80 | 72 | 8 | 0 | 80 | +| 54 | `twa` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | +| 55 | `value_change_count` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | +| 56 | `z_score` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | ## Sorted Op Path Details @@ -78,394 +78,394 @@ Rows with `0` events applied show constructor footprint only; the workload gener ### 1. `n_unique` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 1 | `Txn` | `TxnByCard` | `merchants_per_card_24h` | `card_fp` | 2000 | 80 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByDevice` | `cards_per_device_24h` | `device_id` | 2000 | 80 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByIp` | `cards_per_ip_1h` | `ip_address` | 2000 | 80 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByUser` | `countries_distinct_7d` | `user_id` | 2000 | 80 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByUser` | `ips_distinct_24h` | `user_id` | 2000 | 80 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByUser` | `merchants_distinct_24h` | `user_id` | 2000 | 80 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByDevice` | `users_per_device_24h` | `device_id` | 2000 | 80 | 4392 | 4472 | 2.4% | -| 1 | `Txn` | `TxnByIp` | `users_per_ip_24h` | `ip_address` | 2000 | 80 | 4392 | 4472 | 2.4% | -| 1 | `Txn` | `TxnByMerchant` | `users_per_merchant_24h` | `merchant_id` | 2000 | 80 | 4392 | 4472 | 2.4% | -| 1 | `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 | 80 | 176 | 256 | 0.1% | -| 1 | `Login` | `LoginByUser` | `uas_distinct_login_24h` | `user_id` | 0 | 80 | 176 | 256 | 0.1% | -| 1 | `Signup` | `SignupByIp` | `emails_per_ip_24h` | `ip_address` | 0 | 80 | 176 | 256 | 0.1% | -| 1 | `Signup` | `SignupByIp` | `ssn_reuse_per_ip_30d` | `ip_address` | 0 | 80 | 176 | 256 | 0.1% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 1 | `Txn` | `TxnByCard` | `merchants_per_card_24h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByDevice` | `cards_per_device_24h` | `device_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByIp` | `cards_per_ip_1h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByUser` | `countries_distinct_7d` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByUser` | `ips_distinct_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByUser` | `merchants_distinct_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | +| 1 | `Txn` | `TxnByDevice` | `users_per_device_24h` | `device_id` | 2000 | 80 | 80 | 8 | 72 | 4392 | 4472 | 2.4% | +| 1 | `Txn` | `TxnByIp` | `users_per_ip_24h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 4392 | 4472 | 2.4% | +| 1 | `Txn` | `TxnByMerchant` | `users_per_merchant_24h` | `merchant_id` | 2000 | 80 | 80 | 8 | 72 | 4392 | 4472 | 2.4% | +| 1 | `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | +| 1 | `Login` | `LoginByUser` | `uas_distinct_login_24h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | +| 1 | `Signup` | `SignupByIp` | `emails_per_ip_24h` | `ip_address` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | +| 1 | `Signup` | `SignupByIp` | `ssn_reuse_per_ip_30d` | `ip_address` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | ### 2. `top_k` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 2 | `Txn` | `TxnByUser` | `top_merchants_24h` | `user_id` | 2000 | 80 | 83264 | 83344 | 55.6% | -| 2 | `Txn` | `TxnByIp` | `ip_top_users` | `ip_address` | 2000 | 80 | 66440 | 66520 | 44.4% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 2 | `Txn` | `TxnByUser` | `top_merchants_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 83264 | 83344 | 55.6% | +| 2 | `Txn` | `TxnByIp` | `ip_top_users` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 66440 | 66520 | 44.4% | ### 3. `entropy` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 3 | `Txn` | `TxnByUser` | `mcc_entropy_24h` | `user_id` | 2000 | 80 | 72623 | 72703 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 3 | `Txn` | `TxnByUser` | `mcc_entropy_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 72623 | 72703 | 100.0% | ### 4. `event_type_mix` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 4 | `Txn` | `TxnByUser` | `event_mix_24h` | `user_id` | 2000 | 80 | 20608 | 20688 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 4 | `Txn` | `TxnByUser` | `event_mix_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 20608 | 20688 | 100.0% | ### 5. `quantile` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 5 | `Txn` | `TxnByMerchant` | `merchant_amount_p99_24h` | `merchant_id` | 2000 | 80 | 4464 | 4544 | 25.0% | -| 5 | `Txn` | `TxnByUser` | `amount_p95_24h` | `user_id` | 2000 | 80 | 4464 | 4544 | 25.0% | -| 5 | `Txn` | `TxnByUser` | `p50_amount_24h` | `user_id` | 2000 | 80 | 4464 | 4544 | 25.0% | -| 5 | `Txn` | `TxnByUser` | `p99_amount_24h` | `user_id` | 2000 | 80 | 4464 | 4544 | 25.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 5 | `Txn` | `TxnByMerchant` | `merchant_amount_p99_24h` | `merchant_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | +| 5 | `Txn` | `TxnByUser` | `amount_p95_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | +| 5 | `Txn` | `TxnByUser` | `p50_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | +| 5 | `Txn` | `TxnByUser` | `p99_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | ### 6. `count` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 6 | `Txn` | `TxnByCard` | `decline_count_1h` | `card_fp` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByCard` | `txn_per_card_1h` | `card_fp` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByCard` | `txn_per_card_24h` | `card_fp` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByDevice` | `device_txn_count_24h` | `device_id` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByIp` | `txn_per_ip_1h` | `ip_address` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByIp` | `txn_per_ip_24h` | `ip_address` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByMerchant` | `txn_per_merchant_24h` | `merchant_id` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByUser` | `txn_count_1h` | `user_id` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByUser` | `txn_count_24h` | `user_id` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByUser` | `txn_count_5m` | `user_id` | 2000 | 80 | 256 | 336 | 7.2% | -| 6 | `CardAdd` | `CardAddByDevice` | `card_add_per_device_24h` | `device_id` | 0 | 80 | 176 | 256 | 5.5% | -| 6 | `Login` | `LoginByUser` | `login_count_1h` | `user_id` | 0 | 80 | 176 | 256 | 5.5% | -| 6 | `Login` | `LoginByUser` | `login_count_24h` | `user_id` | 0 | 80 | 176 | 256 | 5.5% | -| 6 | `Refund` | `RefundByUser` | `refund_count_24h` | `user_id` | 0 | 80 | 176 | 256 | 5.5% | -| 6 | `Signup` | `SignupByIp` | `signup_per_ip_24h` | `ip_address` | 0 | 80 | 176 | 256 | 5.5% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 6 | `Txn` | `TxnByCard` | `decline_count_1h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByCard` | `txn_per_card_1h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByCard` | `txn_per_card_24h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByDevice` | `device_txn_count_24h` | `device_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByIp` | `txn_per_ip_1h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByIp` | `txn_per_ip_24h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByMerchant` | `txn_per_merchant_24h` | `merchant_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByUser` | `txn_count_1h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByUser` | `txn_count_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `Txn` | `TxnByUser` | `txn_count_5m` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | +| 6 | `CardAdd` | `CardAddByDevice` | `card_add_per_device_24h` | `device_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | +| 6 | `Login` | `LoginByUser` | `login_count_1h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | +| 6 | `Login` | `LoginByUser` | `login_count_24h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | +| 6 | `Refund` | `RefundByUser` | `refund_count_24h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | +| 6 | `Signup` | `SignupByIp` | `signup_per_ip_24h` | `ip_address` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | ### 7. `burst_count` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 7 | `Txn` | `TxnByCard` | `small_amt_burst_5m` | `card_fp` | 2000 | 80 | 1024 | 1104 | 33.3% | -| 7 | `Txn` | `TxnByUser` | `burst_count_5m` | `user_id` | 2000 | 80 | 1024 | 1104 | 33.3% | -| 7 | `Signup` | `SignupByIp` | `signup_burst_10m` | `ip_address` | 0 | 80 | 1024 | 1104 | 33.3% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 7 | `Txn` | `TxnByCard` | `small_amt_burst_5m` | `card_fp` | 2000 | 80 | 80 | 72 | 8 | 1024 | 1104 | 33.3% | +| 7 | `Txn` | `TxnByUser` | `burst_count_5m` | `user_id` | 2000 | 80 | 80 | 72 | 8 | 1024 | 1104 | 33.3% | +| 7 | `Signup` | `SignupByIp` | `signup_burst_10m` | `ip_address` | 0 | 80 | 80 | 72 | 8 | 1024 | 1104 | 33.3% | ### 8. `distance_from_home` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 8 | `Txn` | `TxnByUser` | `dist_from_home` | `user_id` | 2000 | 80 | 1720 | 1800 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 8 | `Txn` | `TxnByUser` | `dist_from_home` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 1720 | 1800 | 100.0% | ### 9. `reservoir_sample` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 9 | `Txn` | `TxnByUser` | `reservoir_50` | `user_id` | 2000 | 80 | 1600 | 1680 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 9 | `Txn` | `TxnByUser` | `reservoir_50` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 1600 | 1680 | 100.0% | ### 10. `seasonal_deviation` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 10 | `Txn` | `TxnByUser` | `seasonal_dev` | `user_id` | 2000 | 80 | 1427 | 1507 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 10 | `Txn` | `TxnByUser` | `seasonal_dev` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 1427 | 1507 | 100.0% | ### 11. `dow_hour_histogram` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 11 | `Txn` | `TxnByUser` | `dow_hour_hist_30d` | `user_id` | 2000 | 80 | 1344 | 1424 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 11 | `Txn` | `TxnByUser` | `dow_hour_hist_30d` | `user_id` | 2000 | 80 | 80 | 24 | 56 | 1344 | 1424 | 100.0% | ### 12. `bloom_member` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 12 | `Txn` | `TxnByUser` | `device_seen` | `user_id` | 2000 | 80 | 1280 | 1360 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 12 | `Txn` | `TxnByUser` | `device_seen` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 1280 | 1360 | 100.0% | ### 13. `sum` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 13 | `Txn` | `TxnByIp` | `amount_sum_per_ip_1h` | `ip_address` | 2000 | 80 | 256 | 336 | 50.0% | -| 13 | `Txn` | `TxnByUser` | `sum_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 50.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 13 | `Txn` | `TxnByIp` | `amount_sum_per_ip_1h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 50.0% | +| 13 | `Txn` | `TxnByUser` | `sum_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 50.0% | ### 14. `geo_velocity` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 14 | `Txn` | `TxnByUser` | `geo_kmh` | `user_id` | 2000 | 80 | 206 | 286 | 55.3% | -| 14 | `Login` | `LoginByUser` | `login_geo_kmh` | `user_id` | 0 | 80 | 151 | 231 | 44.7% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 14 | `Txn` | `TxnByUser` | `geo_kmh` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 206 | 286 | 55.3% | +| 14 | `Login` | `LoginByUser` | `login_geo_kmh` | `user_id` | 0 | 80 | 80 | 8 | 72 | 151 | 231 | 44.7% | ### 15. `n_unique` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 15 | `Txn` | `TxnByUser` | `unique_cells_24h` | `user_id` | 2000 | 80 | 168 | 248 | 50.0% | -| 15 | `CardAdd` | `CardAddByDevice` | `cards_per_device_lifetime` | `device_id` | 0 | 80 | 168 | 248 | 50.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 15 | `Txn` | `TxnByUser` | `unique_cells_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 168 | 248 | 50.0% | +| 15 | `CardAdd` | `CardAddByDevice` | `cards_per_device_lifetime` | `device_id` | 0 | 80 | 80 | 8 | 72 | 168 | 248 | 50.0% | ### 16. `first_seen` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 16 | `Txn` | `TxnByCard` | `card_first_seen` | `card_fp` | 2000 | 80 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByDevice` | `device_first_seen` | `device_id` | 2000 | 80 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByIp` | `ip_first_seen` | `ip_address` | 2000 | 80 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByMerchant` | `merchant_first_seen` | `merchant_id` | 2000 | 80 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByUser` | `first_seen` | `user_id` | 2000 | 80 | 0 | 80 | 20.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 16 | `Txn` | `TxnByCard` | `card_first_seen` | `card_fp` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByDevice` | `device_first_seen` | `device_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByIp` | `ip_first_seen` | `ip_address` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByMerchant` | `merchant_first_seen` | `merchant_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | +| 16 | `Txn` | `TxnByUser` | `first_seen` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | ### 17. `first_n` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 17 | `Txn` | `TxnByUser` | `first_5_merchants` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 17 | `Txn` | `TxnByUser` | `first_5_merchants` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 256 | 336 | 100.0% | ### 18. `mean` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 18 | `Txn` | `TxnByUser` | `avg_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 18 | `Txn` | `TxnByUser` | `avg_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | ### 19. `min` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 19 | `Txn` | `TxnByUser` | `min_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 19 | `Txn` | `TxnByUser` | `min_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | ### 20. `std` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 20 | `Txn` | `TxnByUser` | `std_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 20 | `Txn` | `TxnByUser` | `std_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | ### 21. `var` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 21 | `Txn` | `TxnByUser` | `var_amount_24h` | `user_id` | 2000 | 80 | 256 | 336 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 21 | `Txn` | `TxnByUser` | `var_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | ### 22. `hour_of_day_histogram` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 22 | `Txn` | `TxnByUser` | `hour_hist_30d` | `user_id` | 2000 | 80 | 255 | 335 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 22 | `Txn` | `TxnByUser` | `hour_hist_30d` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 255 | 335 | 100.0% | ### 23. `geo_spread` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 23 | `Txn` | `TxnByUser` | `geo_spread_24h` | `user_id` | 2000 | 80 | 250 | 330 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 23 | `Txn` | `TxnByUser` | `geo_spread_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 250 | 330 | 100.0% | ### 24. `age` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 24 | `Txn` | `TxnByCard` | `card_age` | `card_fp` | 2000 | 80 | 0 | 80 | 25.0% | -| 24 | `Txn` | `TxnByDevice` | `device_age` | `device_id` | 2000 | 80 | 0 | 80 | 25.0% | -| 24 | `Txn` | `TxnByIp` | `ip_age` | `ip_address` | 2000 | 80 | 0 | 80 | 25.0% | -| 24 | `Txn` | `TxnByUser` | `age` | `user_id` | 2000 | 80 | 0 | 80 | 25.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 24 | `Txn` | `TxnByCard` | `card_age` | `card_fp` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | +| 24 | `Txn` | `TxnByDevice` | `device_age` | `device_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | +| 24 | `Txn` | `TxnByIp` | `ip_age` | `ip_address` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | +| 24 | `Txn` | `TxnByUser` | `age` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | ### 25. `negative_streak` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 25 | `Txn` | `TxnByCard` | `decline_streak_card` | `card_fp` | 2000 | 80 | 0 | 80 | 25.0% | -| 25 | `Txn` | `TxnByUser` | `decline_streak` | `user_id` | 2000 | 80 | 0 | 80 | 25.0% | -| 25 | `CardAdd` | `CardAddByDevice` | `card_add_failure_streak` | `device_id` | 0 | 80 | 0 | 80 | 25.0% | -| 25 | `Login` | `LoginByUser` | `failed_login_streak` | `user_id` | 0 | 80 | 0 | 80 | 25.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 25 | `Txn` | `TxnByCard` | `decline_streak_card` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | +| 25 | `Txn` | `TxnByUser` | `decline_streak` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | +| 25 | `CardAdd` | `CardAddByDevice` | `card_add_failure_streak` | `device_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | +| 25 | `Login` | `LoginByUser` | `failed_login_streak` | `user_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | ### 26. `geo_distance` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 26 | `Txn` | `TxnByUser` | `geo_dist_last` | `user_id` | 2000 | 80 | 192 | 272 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 26 | `Txn` | `TxnByUser` | `geo_dist_last` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 192 | 272 | 100.0% | ### 27. `count` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 27 | `Txn` | `TxnByUser` | `txn_count_lifetime` | `user_id` | 2000 | 80 | 0 | 80 | 33.3% | -| 27 | `Refund` | `RefundByUser` | `chargeback_count_lifetime` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | -| 27 | `Refund` | `RefundByUser` | `refund_count_lifetime` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 27 | `Txn` | `TxnByUser` | `txn_count_lifetime` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 0 | 80 | 33.3% | +| 27 | `Refund` | `RefundByUser` | `chargeback_count_lifetime` | `user_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 33.3% | +| 27 | `Refund` | `RefundByUser` | `refund_count_lifetime` | `user_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 33.3% | ### 28. `last_n` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 28 | `Txn` | `TxnByUser` | `last_5_amounts` | `user_id` | 2000 | 80 | 160 | 240 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 28 | `Txn` | `TxnByUser` | `last_5_amounts` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 160 | 240 | 100.0% | ### 29. `last_seen` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 29 | `Txn` | `TxnByDevice` | `device_last_seen` | `device_id` | 2000 | 80 | 0 | 80 | 33.3% | -| 29 | `Txn` | `TxnByUser` | `last_seen` | `user_id` | 2000 | 80 | 0 | 80 | 33.3% | -| 29 | `Login` | `LoginByUser` | `last_login_at` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 29 | `Txn` | `TxnByDevice` | `device_last_seen` | `device_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | +| 29 | `Txn` | `TxnByUser` | `last_seen` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | +| 29 | `Login` | `LoginByUser` | `last_login_at` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | ### 30. `most_recent_n` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 30 | `Txn` | `TxnByUser` | `recent_5_amts` | `user_id` | 2000 | 80 | 160 | 240 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 30 | `Txn` | `TxnByUser` | `recent_5_amts` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 160 | 240 | 100.0% | ### 31. `time_since` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 31 | `Txn` | `TxnByUser` | `time_since_last` | `user_id` | 2000 | 80 | 0 | 80 | 33.3% | -| 31 | `Login` | `LoginByUser` | `time_since_last_login` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | -| 31 | `Refund` | `RefundByUser` | `time_since_last_cb` | `user_id` | 0 | 80 | 0 | 80 | 33.3% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 31 | `Txn` | `TxnByUser` | `time_since_last` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | +| 31 | `Login` | `LoginByUser` | `time_since_last_login` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | +| 31 | `Refund` | `RefundByUser` | `time_since_last_cb` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | ### 32. `decayed_count` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 32 | `Txn` | `TxnByUser` | `txn_decayed_count_24h` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | -| 32 | `Refund` | `RefundByUser` | `chargeback_decayed_count` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 32 | `Txn` | `TxnByUser` | `txn_decayed_count_24h` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 50.0% | +| 32 | `Refund` | `RefundByUser` | `chargeback_decayed_count` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 50.0% | ### 33. `first_seen_in_window` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 33 | `Txn` | `TxnByUser` | `first_in_24h` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | -| 33 | `Refund` | `RefundByUser` | `first_refund_in_30d` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 33 | `Txn` | `TxnByUser` | `first_in_24h` | `user_id` | 2000 | 80 | 80 | 24 | 56 | 0 | 80 | 50.0% | +| 33 | `Refund` | `RefundByUser` | `first_refund_in_30d` | `user_id` | 0 | 80 | 80 | 24 | 56 | 0 | 80 | 50.0% | ### 34. `streak` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 34 | `Txn` | `TxnByUser` | `txn_streak` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | -| 34 | `Refund` | `RefundByUser` | `cb_streak` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 34 | `Txn` | `TxnByUser` | `txn_streak` | `user_id` | 2000 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | +| 34 | `Refund` | `RefundByUser` | `cb_streak` | `user_id` | 0 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | ### 35. `sum` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 35 | `Txn` | `TxnByUser` | `sum_amount_lifetime` | `user_id` | 2000 | 80 | 0 | 80 | 50.0% | -| 35 | `Refund` | `RefundByUser` | `refund_amount_lifetime` | `user_id` | 0 | 80 | 0 | 80 | 50.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 35 | `Txn` | `TxnByUser` | `sum_amount_lifetime` | `user_id` | 2000 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | +| 35 | `Refund` | `RefundByUser` | `refund_amount_lifetime` | `user_id` | 0 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | ### 36. `lag` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 36 | `Txn` | `TxnByUser` | `amount_lag1` | `user_id` | 2000 | 80 | 64 | 144 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 36 | `Txn` | `TxnByUser` | `amount_lag1` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 64 | 144 | 100.0% | ### 37. `entropy` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 37 | `Txn` | `TxnByUser` | `geo_entropy_24h` | `user_id` | 2000 | 80 | 56 | 136 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 37 | `Txn` | `TxnByUser` | `geo_entropy_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 56 | 136 | 100.0% | ### 38. `time_since_last_n` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 38 | `Txn` | `TxnByUser` | `time_since_last_5` | `user_id` | 2000 | 80 | 40 | 120 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 38 | `Txn` | `TxnByUser` | `time_since_last_5` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 40 | 120 | 100.0% | ### 39. `decayed_sum` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 39 | `Txn` | `TxnByUser` | `amount_decayed_sum_24h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 39 | `Txn` | `TxnByUser` | `amount_decayed_sum_24h` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 40. `delta_from_prev` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 40 | `Txn` | `TxnByUser` | `amount_delta` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 40 | `Txn` | `TxnByUser` | `amount_delta` | `user_id` | 2000 | 80 | 80 | 24 | 56 | 0 | 80 | 100.0% | ### 41. `ew_zscore` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 41 | `Txn` | `TxnByUser` | `amount_ew_zscore` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 41 | `Txn` | `TxnByUser` | `amount_ew_zscore` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 0 | 80 | 100.0% | ### 42. `ewma` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 42 | `Txn` | `TxnByUser` | `amount_ewma_1h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 42 | `Txn` | `TxnByUser` | `amount_ewma_1h` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 43. `ewvar` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 43 | `Txn` | `TxnByUser` | `amount_ewvar_1h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 43 | `Txn` | `TxnByUser` | `amount_ewvar_1h` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 0 | 80 | 100.0% | ### 44. `first` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 44 | `Txn` | `TxnByUser` | `first_amount` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 44 | `Txn` | `TxnByUser` | `first_amount` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 45. `has_seen` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 45 | `Txn` | `TxnByUser` | `has_seen` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 45 | `Txn` | `TxnByUser` | `has_seen` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 46. `inter_arrival_stats` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 46 | `Txn` | `TxnByUser` | `inter_arrival_1h` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 46 | `Txn` | `TxnByUser` | `inter_arrival_1h` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | ### 47. `last` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 47 | `Txn` | `TxnByUser` | `last_amount` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 47 | `Txn` | `TxnByUser` | `last_amount` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 48. `max` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 48 | `Txn` | `TxnByUser` | `max_amount_lifetime` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 48 | `Txn` | `TxnByUser` | `max_amount_lifetime` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 49. `max_streak` / `lifetime` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 49 | `Txn` | `TxnByUser` | `max_streak` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 49 | `Txn` | `TxnByUser` | `max_streak` | `user_id` | 2000 | 80 | 80 | 16 | 64 | 0 | 80 | 100.0% | ### 50. `outlier_count` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 50 | `Txn` | `TxnByUser` | `amount_outliers_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 50 | `Txn` | `TxnByUser` | `amount_outliers_5m` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | ### 51. `rate_of_change` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 51 | `Txn` | `TxnByUser` | `amount_rate_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 51 | `Txn` | `TxnByUser` | `amount_rate_5m` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | ### 52. `trend` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 52 | `Txn` | `TxnByUser` | `amount_trend_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 52 | `Txn` | `TxnByUser` | `amount_trend_5m` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 0 | 80 | 100.0% | ### 53. `trend_residual` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 53 | `Txn` | `TxnByUser` | `amount_trend_resid_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 53 | `Txn` | `TxnByUser` | `amount_trend_resid_5m` | `user_id` | 2000 | 80 | 80 | 72 | 8 | 0 | 80 | 100.0% | ### 54. `twa` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 54 | `Txn` | `TxnByUser` | `amount_twa_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 54 | `Txn` | `TxnByUser` | `amount_twa_5m` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | ### 55. `value_change_count` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 55 | `Txn` | `TxnByUser` | `device_change_count_5m` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 55 | `Txn` | `TxnByUser` | `device_change_count_5m` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | ### 56. `z_score` / `windowed` paths -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|------------|-------------|----------| -| 56 | `Txn` | `TxnByUser` | `amount_z_score` | `user_id` | 2000 | 80 | 0 | 80 | 100.0% | +| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 56 | `Txn` | `TxnByUser` | `amount_z_score` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | ## Top 5 Offenders @@ -474,7 +474,7 @@ Rows with `0` events applied show constructor footprint only; the workload gener - Path: `Txn` -> `TxnByUser` -> `top_merchants_24h` -> `top_k` -> `windowed` - Key path: `user_id` - Events applied: `2000` -- Bytes: stack=80 heap=83264 total=83344 +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=83264 total=83344 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: @@ -493,7 +493,7 @@ Rows with `0` events applied show constructor footprint only; the workload gener - Path: `Txn` -> `TxnByUser` -> `mcc_entropy_24h` -> `entropy` -> `windowed` - Key path: `user_id` - Events applied: `2000` -- Bytes: stack=80 heap=72623 total=72703 +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=72623 total=72703 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: @@ -514,7 +514,7 @@ Rows with `0` events applied show constructor footprint only; the workload gener - Path: `Txn` -> `TxnByIp` -> `ip_top_users` -> `top_k` -> `windowed` - Key path: `ip_address` - Events applied: `2000` -- Bytes: stack=80 heap=66440 total=66520 +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=66440 total=66520 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: @@ -537,7 +537,7 @@ Rows with `0` events applied show constructor footprint only; the workload gener - Path: `Txn` -> `TxnByCard` -> `merchants_per_card_24h` -> `n_unique` -> `windowed` - Key path: `card_fp` - Events applied: `2000` -- Bytes: stack=80 heap=28968 total=29048 +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=28968 total=29048 - Shape: `windowed` (1d) - Recommendation: keep for now; quantify sketch precision and window bucket fanout separately - Breakdown rollup: @@ -556,7 +556,7 @@ Rows with `0` events applied show constructor footprint only; the workload gener - Path: `Txn` -> `TxnByDevice` -> `cards_per_device_24h` -> `n_unique` -> `windowed` - Key path: `device_id` - Events applied: `2000` -- Bytes: stack=80 heap=28968 total=29048 +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=28968 total=29048 - Shape: `windowed` (1d) - Recommendation: keep for now; quantify sketch precision and window bucket fanout separately - Breakdown rollup: @@ -580,5 +580,8 @@ Rows with `0` events applied show constructor footprint only; the workload gener ## Notes - `stack_bytes` is the inline `AggOp` enum slot for each feature. +- `enum_slot_bytes` is the fixed-size `AggOp` enum slot charged to a row; parent rows sum this across child paths. +- `payload_bytes` is the active variant payload inside the enum slot. For boxed variants this is the inline `Box` pointer, while the boxed pointee remains in `heap_bytes`. +- `slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot: `enum_slot_bytes - payload_bytes`. - Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. - Path grain is `source_event -> derivation -> feature -> op -> shape`; path detail rows are children of the op/shape rollups above. From 6ccd908f060927f1b4be704fc95780d59121f6c9 Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Wed, 20 May 2026 22:44:47 -0400 Subject: [PATCH 5/9] Mem profile breakdown per entity --- crates/beava-bench/src/bin/memprofile.rs | 594 ++++- crates/beava-bench/tests/memprofile_smoke.rs | 28 +- memory-profile-fraud-team.md | 2460 ++++++++++++++---- 3 files changed, 2490 insertions(+), 592 deletions(-) diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs index 44854c8e..e7da4879 100644 --- a/crates/beava-bench/src/bin/memprofile.rs +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -3,7 +3,7 @@ use anyhow::{anyhow, Context, Result}; use beava_core::agg_op::{AggExtParams, AggKind, AggOp, AggOpDescriptor, SketchParams}; use beava_core::mem_usage::{MemBreakdown, MemProfile, MemUsage}; -use beava_core::row::{json_value_to_beava_value, Row}; +use beava_core::row::{json_value_to_beava_value, Row, Value}; use clap::Parser; use serde_json::Value as JsonValue; use std::collections::BTreeMap; @@ -39,6 +39,8 @@ struct FeatureSpec { struct ProfileRow { source_events: Vec, derivation: String, + entity_key: String, + entity_events: u64, feature: String, op_name: String, key_path: Vec, @@ -79,13 +81,34 @@ struct ReportInput<'a> { events_by_source: &'a BTreeMap, derivation_count: usize, feature_count: usize, + active_entity_count: usize, + table_profiles: &'a [TableProfile], rows: &'a [ProfileRow], op_totals: &'a [OpTotal], - per_entity_total: usize, + bytes_per_entity_p99: usize, metrics_placeholder: u64, tolerance: f64, } +#[derive(Debug, Clone)] +struct TableSpec { + source_events: Vec, + derivation: String, + key_path: Vec, + features: Vec, +} + +struct TableState { + spec: TableSpec, + entities: BTreeMap, + events_applied: u64, +} + +struct EntityState { + events_applied: u64, + features: Vec, +} + struct ProfileSlot { spec: FeatureSpec, op: AggOp, @@ -93,16 +116,67 @@ struct ProfileSlot { } impl ProfileSlot { - fn matches_source(&self, event_name: &str) -> bool { - self.spec.source_events.is_empty() - || self - .spec - .source_events - .iter() - .any(|source| source == event_name) + fn new(spec: FeatureSpec) -> Self { + Self { + op: AggOp::new(&spec.desc), + spec, + events_applied: 0, + } } } +impl EntityState { + fn new(features: &[FeatureSpec]) -> Self { + Self { + events_applied: 0, + features: features.iter().cloned().map(ProfileSlot::new).collect(), + } + } +} + +#[derive(Debug, Clone)] +struct EntityProfile { + entity_key: String, + events_applied: u64, + profile: MemProfile, + features: Vec, +} + +#[derive(Debug, Clone)] +struct FeatureSummary { + feature: String, + op_name: String, + shape: ProfileShape, + stack_bytes: usize, + heap_p50: usize, + heap_p99: usize, + heap_max: usize, + total_p50: usize, + total_p99: usize, + total_max: usize, +} + +#[derive(Debug, Clone)] +struct TableProfile { + source_events: Vec, + derivation: String, + key_path: Vec, + configured_features: usize, + active_entities: usize, + events_applied: u64, + stack_p50: usize, + stack_p99: usize, + stack_max: usize, + heap_p50: usize, + heap_p99: usize, + heap_max: usize, + total_p50: usize, + total_p99: usize, + total_max: usize, + feature_summaries: Vec, + entities: Vec, +} + fn main() -> Result<()> { let args = Args::parse(); let report = build_report(&args)?; @@ -116,15 +190,7 @@ fn build_report(args: &Args) -> Result { .with_context(|| format!("load workload {:?}", args.workload))?; let features = feature_specs_from_register(&workload.register_payload)?; let feature_count = features.len(); - - let mut slots = features - .into_iter() - .map(|spec| ProfileSlot { - op: AggOp::new(&spec.desc), - spec, - events_applied: 0, - }) - .collect::>(); + let mut tables = table_states_from_features(features)?; let mut events_generated = 0; let mut events_by_source = BTreeMap::new(); @@ -135,49 +201,30 @@ fn build_report(args: &Args) -> Result { .or_insert(0) += 1; let now_ms = event_time_ms(&event.fields).unwrap_or(1_000_000 + idx as i64 * 1_000); let row = row_from_fields(event.fields); - for slot in slots + for table in tables .iter_mut() - .filter(|slot| slot.matches_source(&event.event_name)) + .filter(|table| matches_source(&table.spec.source_events, &event.event_name)) { - let field = slot.spec.desc.field.as_deref(); - slot.op.update(&row, now_ms, field, true); - slot.events_applied += 1; + let Some(entity_key) = entity_key_from_row(&row, &table.spec.key_path) else { + continue; + }; + let entity = table + .entities + .entry(entity_key) + .or_insert_with(|| EntityState::new(&table.spec.features)); + entity.events_applied += 1; + table.events_applied += 1; + for slot in &mut entity.features { + let field = slot.spec.desc.field.as_deref(); + slot.op.update(&row, now_ms, field, true); + slot.events_applied += 1; + } } } - let mut rows = Vec::with_capacity(slots.len()); - for slot in slots { - let spec = slot.spec; - let mut profile = slot.op.mem_profile(); - profile.label = format!( - "{}::{}::{} ({})", - format_sources(&spec.source_events), - spec.derivation, - spec.feature, - spec.op_name - ); - let shape = profile_shape(&spec.desc); - let recommendation = recommendation_for(&spec.op_name, shape, &profile); - rows.push(ProfileRow { - source_events: spec.source_events, - derivation: spec.derivation, - feature: spec.feature, - op_name: spec.op_name, - key_path: spec.key_path, - events_applied: slot.events_applied, - shape, - window_ms: spec.desc.window_ms, - recommendation, - profile, - }); - } + let (mut table_profiles, mut rows) = collect_table_profiles(tables); - rows.sort_by(|a, b| { - b.profile - .total_bytes() - .cmp(&a.profile.total_bytes()) - .then_with(|| a.profile.label.cmp(&b.profile.label)) - }); + rows.sort_by(compare_profile_rows); let mut grouped: BTreeMap<(String, ProfileShape), Vec> = BTreeMap::new(); for row in &rows { @@ -215,7 +262,18 @@ fn build_report(args: &Args) -> Result { .then_with(|| a.shape.cmp(&b.shape)) }); - let per_entity_total: usize = rows.iter().map(|r| r.profile.total_bytes()).sum(); + table_profiles.sort_by(compare_table_profiles); + let active_entity_count = table_profiles.iter().map(|t| t.active_entities).sum(); + let all_entity_totals = table_profiles + .iter() + .flat_map(|table| { + table + .entities + .iter() + .map(|entity| entity.profile.total_bytes()) + }) + .collect::>(); + let bytes_per_entity_p99 = percentile_usize(all_entity_totals, 0.99); Ok(render_markdown(ReportInput { workload: &args.workload, events_requested: args.events, @@ -223,9 +281,11 @@ fn build_report(args: &Args) -> Result { events_by_source: &events_by_source, derivation_count: workload.derivations.len(), feature_count, + active_entity_count, + table_profiles: &table_profiles, rows: &rows, op_totals: &op_totals, - per_entity_total, + bytes_per_entity_p99, metrics_placeholder: args.metrics_bytes_per_entity_p99, tolerance: args.tolerance, })) @@ -257,9 +317,119 @@ fn render_markdown(input: ReportInput<'_>) -> String { input.feature_count )); out.push_str(&format!( - "- Per-entity structural estimate: `{}` bytes\n\n", - input.per_entity_total + "- Active entity rows profiled: `{}`\n", + input.active_entity_count )); + out.push_str(&format!( + "- Bytes per active entity row p99: `{}` bytes\n\n", + input.bytes_per_entity_p99 + )); + + out.push_str("## Per-Entity Table Footprint\n\n"); + out.push_str("| Rank | Table | Source | group_by key | Active entities | Features/entity | Events applied | Stack p50 | Stack p99 | Stack max | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | Top contributor |\n"); + out.push_str("|------|-------|--------|--------------|-----------------|-----------------|----------------|-----------|-----------|-----------|----------|----------|----------|-----------|-----------|-----------|-----------------|\n"); + for (idx, table) in input.table_profiles.iter().enumerate() { + out.push_str(&format!( + "| {} | `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | `{}` |\n", + idx + 1, + table.derivation, + format_sources(&table.source_events), + format_key_path(&table.key_path), + table.active_entities, + table.configured_features, + table.events_applied, + table.stack_p50, + table.stack_p99, + table.stack_max, + table.heap_p50, + table.heap_p99, + table.heap_max, + table.total_p50, + table.total_p99, + table.total_max, + table + .feature_summaries + .first() + .map(|feature| feature.feature.as_str()) + .unwrap_or("-") + )); + } + + out.push_str("\n## Per-Table Entity Details\n\n"); + for table in input.table_profiles { + out.push_str(&format!( + "### `{}` (`{}` by `{}`)\n\n", + table.derivation, + format_sources(&table.source_events), + format_key_path(&table.key_path) + )); + if table.active_entities == 0 { + out.push_str(&format!( + "No active entity rows. Configured features: `{}`. The workload generator emitted no events for this table's source.\n\n", + table.configured_features + )); + continue; + } + + out.push_str("#### Feature Columns Across Entities\n\n"); + out.push_str("| Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max |\n"); + out.push_str("|---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------|\n"); + for feature in &table.feature_summaries { + out.push_str(&format!( + "| `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} |\n", + feature.feature, + feature.op_name, + feature.shape.as_str(), + feature.stack_bytes, + feature.heap_p50, + feature.heap_p99, + feature.heap_max, + feature.total_p50, + feature.total_p99, + feature.total_max + )); + } + + out.push_str("\n#### Largest Entity Rows\n\n"); + out.push_str("| Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors |\n"); + out.push_str("|------------|--------|-------------|------------|-------------|--------------------------|\n"); + for entity in table.entities.iter().take(5) { + out.push_str(&format!( + "| `{}` | {} | {} | {} | {} | {} |\n", + entity.entity_key, + entity.events_applied, + entity.profile.stack_bytes, + entity.profile.heap_bytes, + entity.profile.total_bytes(), + format_top_features(&entity.features, 3) + )); + } + + if let Some(entity) = table.entities.first() { + out.push_str(&format!( + "\n#### Feature Breakdown For Largest Entity `{}`\n\n", + entity.entity_key + )); + out.push_str("| Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes |\n"); + out.push_str("|---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|\n"); + for feature in &entity.features { + out.push_str(&format!( + "| `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} |\n", + feature.feature, + feature.op_name, + feature.shape.as_str(), + feature.events_applied, + feature.profile.stack_bytes, + feature.profile.enum_slot_bytes, + feature.profile.payload_bytes, + feature.profile.slack_bytes, + feature.profile.heap_bytes, + feature.profile.total_bytes() + )); + } + } + out.push('\n'); + } out.push_str("## Sorted Op Table\n\n"); out.push_str("| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes |\n"); @@ -279,23 +449,24 @@ fn render_markdown(input: ReportInput<'_>) -> String { )); } - out.push_str("\n## Sorted Op Path Details\n\n"); - out.push_str("Rows with `0` events applied show constructor footprint only; the workload generator did not emit an event for that path's upstream source.\n\n"); + out.push_str("\n## Sorted Op Entity-Feature Details\n\n"); + out.push_str("Secondary diagnostic view: top entity-feature contributors under each op/shape parent. The table/entity sections above are the primary bytes-per-entity view.\n\n"); for (idx, total) in input.op_totals.iter().enumerate() { out.push_str(&format!( - "### {}. `{}` / `{}` paths\n\n", + "### {}. `{}` / `{}` entity-feature rows\n\n", idx + 1, total.op_name, total.shape.as_str() )); - out.push_str("| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % |\n"); - out.push_str("|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------|\n"); - for row in &total.rows { + out.push_str("| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % |\n"); + out.push_str("|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------|\n"); + for row in total.rows.iter().take(20) { out.push_str(&format!( - "| {} | `{}` | `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} | {:.1}% |\n", + "| {} | `{}` | `{}` | `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} | {:.1}% |\n", idx + 1, format_sources(&row.source_events), row.derivation, + row.entity_key, row.feature, format_key_path(&row.key_path), row.events_applied, @@ -308,6 +479,12 @@ fn render_markdown(input: ReportInput<'_>) -> String { percent_of(row.profile.total_bytes(), total.profile.total_bytes()) )); } + if total.rows.len() > 20 { + out.push_str(&format!( + "\nShowing top 20 of `{}` entity-feature rows for this op/shape.\n", + total.rows.len() + )); + } out.push('\n'); } @@ -329,6 +506,8 @@ fn render_markdown(input: ReportInput<'_>) -> String { row.op_name, row.shape.as_str() )); + out.push_str(&format!("- Entity key: `{}`\n", row.entity_key)); + out.push_str(&format!("- Entity events: `{}`\n", row.entity_events)); out.push_str(&format!( "- Key path: `{}`\n", format_key_path(&row.key_path) @@ -372,7 +551,7 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push_str("## Metrics Coherence\n\n"); let target = input.metrics_placeholder as f64; - let observed = input.per_entity_total as f64; + let observed = input.bytes_per_entity_p99 as f64; let delta = (observed - target).abs(); let allowed = target * input.tolerance; out.push_str(&format!( @@ -380,8 +559,8 @@ fn render_markdown(input: ReportInput<'_>) -> String { input.metrics_placeholder )); out.push_str(&format!( - "- Profile per-entity estimate: `{}` bytes\n", - input.per_entity_total + "- Profile bytes-per-active-entity-row p99: `{}` bytes\n", + input.bytes_per_entity_p99 )); out.push_str(&format!("- Tolerance: `{:.1}%`\n", input.tolerance * 100.0)); if delta <= allowed { @@ -401,7 +580,7 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push_str("- `payload_bytes` is the active variant payload inside the enum slot. For boxed variants this is the inline `Box` pointer, while the boxed pointee remains in `heap_bytes`.\n"); out.push_str("- `slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot: `enum_slot_bytes - payload_bytes`.\n"); out.push_str("- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate.\n"); - out.push_str("- Path grain is `source_event -> derivation -> feature -> op -> shape`; path detail rows are children of the op/shape rollups above.\n"); + out.push_str("- Primary grain is `derivation table -> entity row -> feature column`; op/shape rows remain as secondary diagnostics for implementation-level hotspots.\n"); out } @@ -413,6 +592,239 @@ fn percent_of(part: usize, total: usize) -> f64 { } } +fn table_states_from_features(features: Vec) -> Result> { + let mut grouped: BTreeMap = BTreeMap::new(); + for feature in features { + let entry = grouped + .entry(feature.derivation.clone()) + .or_insert_with(|| TableSpec { + source_events: feature.source_events.clone(), + derivation: feature.derivation.clone(), + key_path: feature.key_path.clone(), + features: Vec::new(), + }); + if entry.source_events != feature.source_events || entry.key_path != feature.key_path { + return Err(anyhow!( + "derivation {:?} has inconsistent source/key path", + feature.derivation + )); + } + entry.features.push(feature); + } + Ok(grouped + .into_values() + .map(|mut spec| { + spec.features.sort_by(|a, b| a.feature.cmp(&b.feature)); + TableState { + spec, + entities: BTreeMap::new(), + events_applied: 0, + } + }) + .collect()) +} + +fn collect_table_profiles(tables: Vec) -> (Vec, Vec) { + let mut all_rows = Vec::new(); + let mut table_profiles = Vec::new(); + for table in tables { + let mut entities = Vec::new(); + for (entity_key, entity) in table.entities { + let mut entity_profile = MemProfile::new(entity_key.clone(), 0); + let mut feature_rows = Vec::with_capacity(entity.features.len()); + for slot in entity.features { + let spec = slot.spec; + let mut profile = slot.op.mem_profile(); + profile.label = format!( + "{}::{}[{}]::{} ({})", + format_sources(&spec.source_events), + spec.derivation, + entity_key, + spec.feature, + spec.op_name + ); + add_profile_totals(&mut entity_profile, &profile); + let shape = profile_shape(&spec.desc); + let recommendation = recommendation_for(&spec.op_name, shape, &profile); + let row = ProfileRow { + source_events: spec.source_events, + derivation: spec.derivation, + entity_key: entity_key.clone(), + entity_events: entity.events_applied, + feature: spec.feature, + op_name: spec.op_name, + key_path: spec.key_path, + events_applied: slot.events_applied, + window_ms: spec.desc.window_ms, + recommendation, + shape, + profile, + }; + feature_rows.push(row.clone()); + all_rows.push(row); + } + feature_rows.sort_by(compare_profile_rows); + entities.push(EntityProfile { + entity_key, + events_applied: entity.events_applied, + profile: entity_profile, + features: feature_rows, + }); + } + entities.sort_by(compare_entity_profiles); + let feature_summaries = feature_summaries_for_table(&entities); + let stack_values = entities + .iter() + .map(|entity| entity.profile.stack_bytes) + .collect::>(); + let heap_values = entities + .iter() + .map(|entity| entity.profile.heap_bytes) + .collect::>(); + let total_values = entities + .iter() + .map(|entity| entity.profile.total_bytes()) + .collect::>(); + table_profiles.push(TableProfile { + source_events: table.spec.source_events, + derivation: table.spec.derivation, + key_path: table.spec.key_path, + configured_features: table.spec.features.len(), + active_entities: entities.len(), + events_applied: table.events_applied, + stack_p50: percentile_usize(stack_values.clone(), 0.50), + stack_p99: percentile_usize(stack_values.clone(), 0.99), + stack_max: stack_values.into_iter().max().unwrap_or(0), + heap_p50: percentile_usize(heap_values.clone(), 0.50), + heap_p99: percentile_usize(heap_values.clone(), 0.99), + heap_max: heap_values.into_iter().max().unwrap_or(0), + total_p50: percentile_usize(total_values.clone(), 0.50), + total_p99: percentile_usize(total_values.clone(), 0.99), + total_max: total_values.into_iter().max().unwrap_or(0), + feature_summaries, + entities, + }); + } + (table_profiles, all_rows) +} + +fn feature_summaries_for_table(entities: &[EntityProfile]) -> Vec { + let mut grouped: BTreeMap<(String, String, ProfileShape), Vec<&ProfileRow>> = BTreeMap::new(); + for entity in entities { + for feature in &entity.features { + grouped + .entry(( + feature.feature.clone(), + feature.op_name.clone(), + feature.shape, + )) + .or_default() + .push(feature); + } + } + let mut summaries = grouped + .into_iter() + .map(|((feature, op_name, shape), rows)| { + let stack_values = rows + .iter() + .map(|row| row.profile.stack_bytes) + .collect::>(); + let heap_values = rows + .iter() + .map(|row| row.profile.heap_bytes) + .collect::>(); + let total_values = rows + .iter() + .map(|row| row.profile.total_bytes()) + .collect::>(); + FeatureSummary { + feature, + op_name, + shape, + stack_bytes: percentile_usize(stack_values, 0.99), + heap_p50: percentile_usize(heap_values.clone(), 0.50), + heap_p99: percentile_usize(heap_values.clone(), 0.99), + heap_max: heap_values.into_iter().max().unwrap_or(0), + total_p50: percentile_usize(total_values.clone(), 0.50), + total_p99: percentile_usize(total_values.clone(), 0.99), + total_max: total_values.into_iter().max().unwrap_or(0), + } + }) + .collect::>(); + summaries.sort_by(|a, b| { + b.total_p99 + .cmp(&a.total_p99) + .then_with(|| b.heap_p99.cmp(&a.heap_p99)) + .then_with(|| a.feature.cmp(&b.feature)) + }); + summaries +} + +fn add_profile_totals(total: &mut MemProfile, profile: &MemProfile) { + total.stack_bytes += profile.stack_bytes; + total.enum_slot_bytes += profile.enum_slot_bytes; + total.payload_bytes += profile.payload_bytes; + total.slack_bytes += profile.slack_bytes; + total.heap_bytes += profile.heap_bytes; + total.breakdown.extend(profile.breakdown.clone()); +} + +fn percentile_usize(mut values: Vec, q: f64) -> usize { + if values.is_empty() { + return 0; + } + values.sort_unstable(); + let rank = ((values.len() as f64) * q).ceil() as usize; + let idx = rank.saturating_sub(1).min(values.len() - 1); + values[idx] +} + +fn compare_table_profiles(a: &TableProfile, b: &TableProfile) -> std::cmp::Ordering { + b.total_p99 + .cmp(&a.total_p99) + .then_with(|| b.heap_p99.cmp(&a.heap_p99)) + .then_with(|| b.active_entities.cmp(&a.active_entities)) + .then_with(|| a.derivation.cmp(&b.derivation)) +} + +fn compare_entity_profiles(a: &EntityProfile, b: &EntityProfile) -> std::cmp::Ordering { + b.profile + .total_bytes() + .cmp(&a.profile.total_bytes()) + .then_with(|| b.events_applied.cmp(&a.events_applied)) + .then_with(|| a.entity_key.cmp(&b.entity_key)) +} + +fn matches_source(sources: &[String], event_name: &str) -> bool { + sources.is_empty() || sources.iter().any(|source| source == event_name) +} + +fn entity_key_from_row(row: &Row, key_path: &[String]) -> Option { + if key_path.is_empty() { + return Some("".to_string()); + } + key_path + .iter() + .map(|key| row.get(key).map(value_key_part)) + .collect::>>() + .map(|parts| parts.join("|")) +} + +fn value_key_part(value: &Value) -> String { + match value { + Value::Null => "null".to_string(), + Value::Str(s) => s.to_string(), + Value::I64(v) => v.to_string(), + Value::F64(v) => format!("{v}"), + Value::Bool(v) => v.to_string(), + Value::Bytes(bytes) => format!("<{} bytes>", bytes.len()), + Value::Datetime(v) => v.to_string(), + Value::Json(v) => v.to_string(), + Value::List(values) => format!("", values.len()), + Value::Map(values) => format!("", values.len()), + } +} + fn format_sources(sources: &[String]) -> String { if sources.is_empty() { "*".to_string() @@ -429,6 +841,21 @@ fn format_key_path(keys: &[String]) -> String { } } +fn format_top_features(features: &[ProfileRow], limit: usize) -> String { + features + .iter() + .take(limit) + .map(|feature| { + format!( + "`{}`={} bytes", + feature.feature, + feature.profile.total_bytes() + ) + }) + .collect::>() + .join(", ") +} + fn top_breakdown(entries: &[MemBreakdown], limit: usize) -> Vec { let mut entries = entries.to_vec(); entries.sort_by(|a, b| b.bytes.cmp(&a.bytes).then_with(|| a.label.cmp(&b.label))); @@ -443,6 +870,7 @@ fn compare_profile_rows(a: &ProfileRow, b: &ProfileRow) -> std::cmp::Ordering { .then_with(|| b.events_applied.cmp(&a.events_applied)) .then_with(|| format_sources(&a.source_events).cmp(&format_sources(&b.source_events))) .then_with(|| a.derivation.cmp(&b.derivation)) + .then_with(|| a.entity_key.cmp(&b.entity_key)) .then_with(|| a.feature.cmp(&b.feature)) .then_with(|| a.op_name.cmp(&b.op_name)) } @@ -801,17 +1229,33 @@ mod tests { assert!(report.contains("Events replayed from generator: `5`")); assert!(report.contains(" - `Txn`: `5`")); assert!(!report.contains("Events replayed per op")); + assert!(report.contains("Active entity rows profiled:")); + assert!(report.contains("Bytes per active entity row p99:")); + assert!(report.contains("## Per-Entity Table Footprint")); + assert!(report.contains( + "| Rank | Table | Source | group_by key | Active entities | Features/entity | Events applied | Stack p50 | Stack p99 | Stack max | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | Top contributor |" + )); + assert!(report.contains("`TxnByUser` | `Txn` | `user_id`")); + assert!(report.contains("## Per-Table Entity Details")); + assert!(report.contains("### `TxnByUser` (`Txn` by `user_id`)")); + assert!(report.contains("#### Feature Columns Across Entities")); + assert!(report.contains("#### Largest Entity Rows")); + assert!(report.contains("#### Feature Breakdown For Largest Entity")); + assert!( + report.contains("The workload generator emitted no events for this table's source.") + ); assert!(report.contains("## Sorted Op Table")); - assert!(report.contains("## Sorted Op Path Details")); + assert!(report.contains("## Sorted Op Entity-Feature Details")); assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); assert!(report.contains("| Rank | Op | Shape |")); assert!(report.contains( - "| Parent rank | Source event | Derivation | Feature | Key path | Events applied |" + "| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied |" )); - assert!(report - .contains("| `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 |")); - assert!(report.contains("- Events applied: `5`")); + assert!(report.contains("`txn_count_lifetime` | `user_id` | 1 |")); + assert!(report.contains("- Entity key:")); + assert!(report.contains("- Entity events:")); + assert!(report.contains("- Events applied: `1`")); } } diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs index 78b59be1..d0a4a8f4 100644 --- a/crates/beava-bench/tests/memprofile_smoke.rs +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -24,8 +24,21 @@ fn memprofile_smoke_writes_required_sections() { assert!(report.contains("Events replayed from generator: `50`")); assert!(report.contains(" - `Txn`: `50`")); assert!(!report.contains("Events replayed per op")); + assert!(report.contains("Active entity rows profiled:")); + assert!(report.contains("Bytes per active entity row p99:")); + assert!(report.contains("## Per-Entity Table Footprint")); + assert!(report.contains( + "| Rank | Table | Source | group_by key | Active entities | Features/entity | Events applied | Stack p50 | Stack p99 | Stack max | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | Top contributor |" + )); + assert!(report.contains("`TxnByUser` | `Txn` | `user_id`")); + assert!(report.contains("## Per-Table Entity Details")); + assert!(report.contains("### `TxnByUser` (`Txn` by `user_id`)")); + assert!(report.contains("#### Feature Columns Across Entities")); + assert!(report.contains("#### Largest Entity Rows")); + assert!(report.contains("#### Feature Breakdown For Largest Entity")); + assert!(report.contains("The workload generator emitted no events for this table's source.")); assert!(report.contains("## Sorted Op Table")); - assert!(report.contains("## Sorted Op Path Details")); + assert!(report.contains("## Sorted Op Entity-Feature Details")); assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); @@ -34,16 +47,13 @@ fn memprofile_smoke_writes_required_sections() { assert!(report.contains("payload_bytes")); assert!(report.contains("slack_bytes")); assert!(report.contains( - "| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes |" - )); - assert!(report.contains( - "| `Txn` | `TxnByUser` | `txn_count_lifetime` | `user_id` | 50 | 80 | 80 | 8 | 72 | 0 | 80 |" + "| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes |" )); - assert!( - report.contains("| `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 |") - ); + assert!(report.contains("`txn_count_lifetime` | `user_id` | 1 | 80 | 80 | 8 | 72 | 0 | 80 |")); assert!(report.contains("- Path: `Txn` ->")); - assert!(report.contains("- Events applied: `50`")); + assert!(report.contains("- Entity key:")); + assert!(report.contains("- Entity events:")); + assert!(report.contains("- Events applied: `1`")); assert!(report.contains("stack=80 (enum_slot_bytes=80 payload_bytes=")); assert!(report.contains("`windowed`")); assert!(report.contains("`lifetime`")); diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 054ff852..8f2706a5 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -9,573 +9,2017 @@ - `Txn`: `2000` - Derivations discovered: `9` - Aggregate features discovered: `111` -- Per-entity structural estimate: `474904` bytes +- Active entity rows profiled: `5422` +- Bytes per active entity row p99: `26655` bytes + +## Per-Entity Table Footprint + +| Rank | Table | Source | group_by key | Active entities | Features/entity | Events applied | Stack p50 | Stack p99 | Stack max | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | Top contributor | +|------|-------|--------|--------------|-----------------|-----------------|----------------|-----------|-----------|-----------|----------|----------|----------|-----------|-----------|-----------|-----------------| +| 1 | `TxnByUser` | `Txn` | `user_id` | 1982 | 62 | 2000 | 4960 | 4960 | 4960 | 21689 | 21697 | 22013 | 26649 | 26657 | 26973 | `amount_p95_24h` | +| 2 | `TxnByMerchant` | `Txn` | `merchant_id` | 863 | 4 | 2000 | 320 | 320 | 320 | 3096 | 3096 | 3096 | 3416 | 3416 | 3416 | `merchant_amount_p99_24h` | +| 3 | `TxnByIp` | `Txn` | `ip_address` | 862 | 8 | 2000 | 640 | 640 | 640 | 2224 | 2608 | 2896 | 2864 | 3248 | 3536 | `ip_top_users` | +| 4 | `TxnByCard` | `Txn` | `card_fp` | 854 | 8 | 2000 | 640 | 640 | 640 | 2216 | 2216 | 2216 | 2856 | 2856 | 2856 | `small_amt_burst_5m` | +| 5 | `TxnByDevice` | `Txn` | `device_id` | 861 | 6 | 2000 | 480 | 480 | 480 | 1104 | 1104 | 1104 | 1584 | 1584 | 1584 | `cards_per_device_24h` | +| 6 | `CardAddByDevice` | `CardAdd` | `device_id` | 0 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | +| 7 | `LoginByUser` | `Login` | `user_id` | 0 | 8 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | +| 8 | `RefundByUser` | `Refund` | `user_id` | 0 | 8 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | +| 9 | `SignupByIp` | `Signup` | `ip_address` | 0 | 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | + +## Per-Table Entity Details + +### `TxnByUser` (`Txn` by `user_id`) + +#### Feature Columns Across Entities + +| Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | +|---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| +| `amount_p95_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `p50_amount_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `p99_amount_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `dist_from_home` | `distance_from_home` | `lifetime` | 80 | 1720 | 1720 | 1720 | 1800 | 1800 | 1800 | +| `reservoir_50` | `reservoir_sample` | `lifetime` | 80 | 1600 | 1600 | 1600 | 1680 | 1680 | 1680 | +| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 80 | 1424 | 1427 | 1427 | 1504 | 1507 | 1507 | +| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1344 | 1344 | 1424 | 1424 | 1424 | +| `device_seen` | `bloom_member` | `lifetime` | 80 | 1280 | 1280 | 1280 | 1360 | 1360 | 1360 | +| `burst_count_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | +| `top_merchants_24h` | `top_k` | `windowed` | 80 | 512 | 512 | 608 | 592 | 592 | 688 | +| `countries_distinct_7d` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `ips_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `merchants_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `mcc_entropy_24h` | `entropy` | `windowed` | 80 | 396 | 396 | 480 | 476 | 476 | 560 | +| `avg_amount_24h` | `mean` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `min_amount_24h` | `min` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `std_amount_24h` | `std` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `sum_amount_24h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_count_5m` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `var_amount_24h` | `var` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 80 | 252 | 252 | 252 | 332 | 332 | 332 | +| `geo_spread_24h` | `geo_spread` | `lifetime` | 80 | 215 | 217 | 246 | 295 | 297 | 326 | +| `event_mix_24h` | `event_type_mix` | `lifetime` | 80 | 208 | 208 | 288 | 288 | 288 | 368 | +| `geo_kmh` | `geo_velocity` | `lifetime` | 80 | 192 | 194 | 209 | 272 | 274 | 289 | +| `geo_dist_last` | `geo_distance` | `lifetime` | 80 | 177 | 179 | 193 | 257 | 259 | 273 | +| `unique_cells_24h` | `n_unique` | `lifetime` | 80 | 168 | 168 | 168 | 248 | 248 | 248 | +| `last_5_amounts` | `last_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | +| `recent_5_amts` | `most_recent_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | +| `first_5_merchants` | `first_n` | `lifetime` | 80 | 128 | 128 | 128 | 208 | 208 | 208 | +| `amount_lag1` | `lag` | `lifetime` | 80 | 64 | 64 | 64 | 144 | 144 | 144 | +| `geo_entropy_24h` | `entropy` | `lifetime` | 80 | 56 | 56 | 56 | 136 | 136 | 136 | +| `time_since_last_5` | `time_since_last_n` | `lifetime` | 80 | 40 | 40 | 40 | 120 | 120 | 120 | +| `age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_delta` | `delta_from_prev` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_ewma_1h` | `ewma` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_ewvar_1h` | `ewvar` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_outliers_5m` | `outlier_count` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_rate_5m` | `rate_of_change` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_trend_5m` | `trend` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_twa_5m` | `twa` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_z_score` | `z_score` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `decline_streak` | `negative_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `device_change_count_5m` | `value_change_count` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `first_amount` | `first` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `first_in_24h` | `first_seen_in_window` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `has_seen` | `has_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `last_amount` | `last` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `last_seen` | `last_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `max_amount_lifetime` | `max` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `max_streak` | `max_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `sum_amount_lifetime` | `sum` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `time_since_last` | `time_since` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `txn_count_lifetime` | `count` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `txn_streak` | `streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | + +#### Largest Entity Rows + +| Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | +|------------|--------|-------------|------------|-------------|--------------------------| +| `k00029943` | 2 | 4960 | 22013 | 26973 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00055008` | 2 | 4960 | 22013 | 26973 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00067574` | 2 | 4960 | 22010 | 26970 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00070333` | 2 | 4960 | 22009 | 26969 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00022821` | 2 | 4960 | 22008 | 26968 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | + +#### Feature Breakdown For Largest Entity `k00029943` + +| Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | +|---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| +| `amount_p95_24h` | `quantile` | `windowed` | 2 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `p50_amount_24h` | `quantile` | `windowed` | 2 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `p99_amount_24h` | `quantile` | `windowed` | 2 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `dist_from_home` | `distance_from_home` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | +| `reservoir_50` | `reservoir_sample` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | +| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 1426 | 1506 | +| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | +| `device_seen` | `bloom_member` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | +| `burst_count_5m` | `burst_count` | `windowed` | 2 | 80 | 80 | 72 | 8 | 1024 | 1104 | +| `top_merchants_24h` | `top_k` | `windowed` | 2 | 80 | 80 | 8 | 72 | 608 | 688 | +| `mcc_entropy_24h` | `entropy` | `windowed` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | +| `countries_distinct_7d` | `n_unique` | `windowed` | 2 | 80 | 80 | 8 | 72 | 424 | 504 | +| `ips_distinct_24h` | `n_unique` | `windowed` | 2 | 80 | 80 | 8 | 72 | 424 | 504 | +| `merchants_distinct_24h` | `n_unique` | `windowed` | 2 | 80 | 80 | 8 | 72 | 424 | 504 | +| `event_mix_24h` | `event_type_mix` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | +| `avg_amount_24h` | `mean` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `min_amount_24h` | `min` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `std_amount_24h` | `std` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `sum_amount_24h` | `sum` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_count_1h` | `count` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_count_24h` | `count` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_count_5m` | `count` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `var_amount_24h` | `var` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | +| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | +| `geo_spread_24h` | `geo_spread` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 246 | 326 | +| `geo_kmh` | `geo_velocity` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | +| `geo_dist_last` | `geo_distance` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | +| `unique_cells_24h` | `n_unique` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | +| `last_5_amounts` | `last_n` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | +| `recent_5_amts` | `most_recent_n` | `lifetime` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | +| `first_5_merchants` | `first_n` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | +| `amount_lag1` | `lag` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | +| `geo_entropy_24h` | `entropy` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | +| `time_since_last_5` | `time_since_last_n` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | +| `age` | `age` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_delta` | `delta_from_prev` | `lifetime` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | +| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_ewma_1h` | `ewma` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_ewvar_1h` | `ewvar` | `lifetime` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_outliers_5m` | `outlier_count` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | +| `amount_rate_5m` | `rate_of_change` | `windowed` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_trend_5m` | `trend` | `windowed` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | +| `amount_twa_5m` | `twa` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | +| `amount_z_score` | `z_score` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | +| `decline_streak` | `negative_streak` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | +| `device_change_count_5m` | `value_change_count` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | +| `first_amount` | `first` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `first_in_24h` | `first_seen_in_window` | `windowed` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | +| `first_seen` | `first_seen` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `has_seen` | `has_seen` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | +| `last_amount` | `last` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `last_seen` | `last_seen` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `max_amount_lifetime` | `max` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `max_streak` | `max_streak` | `lifetime` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | +| `sum_amount_lifetime` | `sum` | `lifetime` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | +| `time_since_last` | `time_since` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `txn_count_lifetime` | `count` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | +| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | +| `txn_streak` | `streak` | `lifetime` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | + +### `TxnByMerchant` (`Txn` by `merchant_id`) + +#### Feature Columns Across Entities + +| Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | +|---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| +| `merchant_amount_p99_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `users_per_merchant_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `txn_per_merchant_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `merchant_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | + +#### Largest Entity Rows + +| Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | +|------------|--------|-------------|------------|-------------|--------------------------| +| `s470` | 9 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | +| `s176` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | +| `s278` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | +| `s387` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | +| `s507` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | + +#### Feature Breakdown For Largest Entity `s470` + +| Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | +|---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| +| `merchant_amount_p99_24h` | `quantile` | `windowed` | 9 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `users_per_merchant_24h` | `n_unique` | `windowed` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | +| `txn_per_merchant_24h` | `count` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | +| `merchant_first_seen` | `first_seen` | `lifetime` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | + +### `TxnByIp` (`Txn` by `ip_address`) + +#### Feature Columns Across Entities + +| Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | +|---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| +| `ip_top_users` | `top_k` | `windowed` | 80 | 608 | 992 | 1280 | 688 | 1072 | 1360 | +| `cards_per_ip_1h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `users_per_ip_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `amount_sum_per_ip_1h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_per_ip_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_per_ip_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `ip_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `ip_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | + +#### Largest Entity Rows + +| Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | +|------------|--------|-------------|------------|-------------|--------------------------| +| `s389` | 9 | 640 | 2896 | 3536 | `ip_top_users`=1360 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | +| `s122` | 8 | 640 | 2800 | 3440 | `ip_top_users`=1264 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | +| `s466` | 8 | 640 | 2800 | 3440 | `ip_top_users`=1264 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | +| `s132` | 7 | 640 | 2704 | 3344 | `ip_top_users`=1168 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | +| `s226` | 7 | 640 | 2704 | 3344 | `ip_top_users`=1168 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | + +#### Feature Breakdown For Largest Entity `s389` + +| Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | +|---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| +| `ip_top_users` | `top_k` | `windowed` | 9 | 80 | 80 | 8 | 72 | 1280 | 1360 | +| `cards_per_ip_1h` | `n_unique` | `windowed` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | +| `users_per_ip_24h` | `n_unique` | `windowed` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | +| `amount_sum_per_ip_1h` | `sum` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_ip_1h` | `count` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_ip_24h` | `count` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | +| `ip_age` | `age` | `lifetime` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | +| `ip_first_seen` | `first_seen` | `lifetime` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | + +### `TxnByCard` (`Txn` by `card_fp`) + +#### Feature Columns Across Entities + +| Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | +|---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| +| `small_amt_burst_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | +| `merchants_per_card_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `decline_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_per_card_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_per_card_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `card_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `card_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `decline_streak_card` | `negative_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | + +#### Largest Entity Rows + +| Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | +|------------|--------|-------------|------------|-------------|--------------------------| +| `s409` | 10 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | +| `s179` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | +| `s42` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | +| `s450` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | +| `s896` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | + +#### Feature Breakdown For Largest Entity `s409` + +| Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | +|---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| +| `small_amt_burst_5m` | `burst_count` | `windowed` | 10 | 80 | 80 | 72 | 8 | 1024 | 1104 | +| `merchants_per_card_24h` | `n_unique` | `windowed` | 10 | 80 | 80 | 8 | 72 | 424 | 504 | +| `decline_count_1h` | `count` | `windowed` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_card_1h` | `count` | `windowed` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_card_24h` | `count` | `windowed` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | +| `card_age` | `age` | `lifetime` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | +| `card_first_seen` | `first_seen` | `lifetime` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | +| `decline_streak_card` | `negative_streak` | `lifetime` | 10 | 80 | 80 | 8 | 72 | 0 | 80 | + +### `TxnByDevice` (`Txn` by `device_id`) + +#### Feature Columns Across Entities + +| Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | +|---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| +| `cards_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `users_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `device_txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `device_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `device_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `device_last_seen` | `last_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | + +#### Largest Entity Rows + +| Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | +|------------|--------|-------------|------------|-------------|--------------------------| +| `s377` | 7 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | +| `s717` | 7 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | +| `s743` | 7 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | +| `s107` | 6 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | +| `s171` | 6 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | + +#### Feature Breakdown For Largest Entity `s377` + +| Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | +|---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| +| `cards_per_device_24h` | `n_unique` | `windowed` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | +| `users_per_device_24h` | `n_unique` | `windowed` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | +| `device_txn_count_24h` | `count` | `windowed` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | +| `device_age` | `age` | `lifetime` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | +| `device_first_seen` | `first_seen` | `lifetime` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | +| `device_last_seen` | `last_seen` | `lifetime` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | + +### `CardAddByDevice` (`CardAdd` by `device_id`) + +No active entity rows. Configured features: `3`. The workload generator emitted no events for this table's source. + +### `LoginByUser` (`Login` by `user_id`) + +No active entity rows. Configured features: `8`. The workload generator emitted no events for this table's source. + +### `RefundByUser` (`Refund` by `user_id`) + +No active entity rows. Configured features: `8`. The workload generator emitted no events for this table's source. + +### `SignupByIp` (`Signup` by `ip_address`) + +No active entity rows. Configured features: `4`. The workload generator emitted no events for this table's source. ## Sorted Op Table | Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |------|----|-------|-------------|-----------------|---------------|-------------|------------|-------------| -| 1 | `n_unique` | `windowed` | 1040 | 1040 | 104 | 936 | 187688 | 188728 | -| 2 | `top_k` | `windowed` | 160 | 160 | 16 | 144 | 149704 | 149864 | -| 3 | `entropy` | `windowed` | 80 | 80 | 8 | 72 | 72623 | 72703 | -| 4 | `event_type_mix` | `lifetime` | 80 | 80 | 8 | 72 | 20608 | 20688 | -| 5 | `quantile` | `windowed` | 320 | 320 | 32 | 288 | 17856 | 18176 | -| 6 | `count` | `windowed` | 1200 | 1200 | 120 | 1080 | 3440 | 4640 | -| 7 | `burst_count` | `windowed` | 240 | 240 | 216 | 24 | 3072 | 3312 | -| 8 | `distance_from_home` | `lifetime` | 80 | 80 | 8 | 72 | 1720 | 1800 | -| 9 | `reservoir_sample` | `lifetime` | 80 | 80 | 40 | 40 | 1600 | 1680 | -| 10 | `seasonal_deviation` | `lifetime` | 80 | 80 | 8 | 72 | 1427 | 1507 | -| 11 | `dow_hour_histogram` | `lifetime` | 80 | 80 | 24 | 56 | 1344 | 1424 | -| 12 | `bloom_member` | `lifetime` | 80 | 80 | 8 | 72 | 1280 | 1360 | -| 13 | `sum` | `windowed` | 160 | 160 | 16 | 144 | 512 | 672 | -| 14 | `geo_velocity` | `lifetime` | 160 | 160 | 16 | 144 | 357 | 517 | -| 15 | `n_unique` | `lifetime` | 160 | 160 | 16 | 144 | 336 | 496 | -| 16 | `first_seen` | `lifetime` | 400 | 400 | 160 | 240 | 0 | 400 | -| 17 | `first_n` | `lifetime` | 80 | 80 | 32 | 48 | 256 | 336 | -| 18 | `mean` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | -| 19 | `min` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | -| 20 | `std` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | -| 21 | `var` | `windowed` | 80 | 80 | 8 | 72 | 256 | 336 | -| 22 | `hour_of_day_histogram` | `lifetime` | 80 | 80 | 8 | 72 | 255 | 335 | -| 23 | `geo_spread` | `lifetime` | 80 | 80 | 8 | 72 | 250 | 330 | -| 24 | `age` | `lifetime` | 320 | 320 | 128 | 192 | 0 | 320 | -| 25 | `negative_streak` | `lifetime` | 320 | 320 | 32 | 288 | 0 | 320 | -| 26 | `geo_distance` | `lifetime` | 80 | 80 | 8 | 72 | 192 | 272 | -| 27 | `count` | `lifetime` | 240 | 240 | 24 | 216 | 0 | 240 | -| 28 | `last_n` | `lifetime` | 80 | 80 | 40 | 40 | 160 | 240 | -| 29 | `last_seen` | `lifetime` | 240 | 240 | 96 | 144 | 0 | 240 | -| 30 | `most_recent_n` | `lifetime` | 80 | 80 | 48 | 32 | 160 | 240 | -| 31 | `time_since` | `lifetime` | 240 | 240 | 96 | 144 | 0 | 240 | -| 32 | `decayed_count` | `lifetime` | 160 | 160 | 64 | 96 | 0 | 160 | -| 33 | `first_seen_in_window` | `windowed` | 160 | 160 | 48 | 112 | 0 | 160 | -| 34 | `streak` | `lifetime` | 160 | 160 | 32 | 128 | 0 | 160 | -| 35 | `sum` | `lifetime` | 160 | 160 | 32 | 128 | 0 | 160 | -| 36 | `lag` | `lifetime` | 80 | 80 | 40 | 40 | 64 | 144 | -| 37 | `entropy` | `lifetime` | 80 | 80 | 8 | 72 | 56 | 136 | -| 38 | `time_since_last_n` | `lifetime` | 80 | 80 | 40 | 40 | 40 | 120 | -| 39 | `decayed_sum` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | -| 40 | `delta_from_prev` | `lifetime` | 80 | 80 | 24 | 56 | 0 | 80 | -| 41 | `ew_zscore` | `lifetime` | 80 | 80 | 48 | 32 | 0 | 80 | -| 42 | `ewma` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | -| 43 | `ewvar` | `lifetime` | 80 | 80 | 48 | 32 | 0 | 80 | -| 44 | `first` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | -| 45 | `has_seen` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | -| 46 | `inter_arrival_stats` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | -| 47 | `last` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | -| 48 | `max` | `lifetime` | 80 | 80 | 32 | 48 | 0 | 80 | -| 49 | `max_streak` | `lifetime` | 80 | 80 | 16 | 64 | 0 | 80 | -| 50 | `outlier_count` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | -| 51 | `rate_of_change` | `windowed` | 80 | 80 | 32 | 48 | 0 | 80 | -| 52 | `trend` | `windowed` | 80 | 80 | 48 | 32 | 0 | 80 | -| 53 | `trend_residual` | `windowed` | 80 | 80 | 72 | 8 | 0 | 80 | -| 54 | `twa` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | -| 55 | `value_change_count` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | -| 56 | `z_score` | `windowed` | 80 | 80 | 40 | 40 | 0 | 80 | - -## Sorted Op Path Details - -Rows with `0` events applied show constructor footprint only; the workload generator did not emit an event for that path's upstream source. - -### 1. `n_unique` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 1 | `Txn` | `TxnByCard` | `merchants_per_card_24h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByDevice` | `cards_per_device_24h` | `device_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByIp` | `cards_per_ip_1h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByUser` | `countries_distinct_7d` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByUser` | `ips_distinct_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByUser` | `merchants_distinct_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 28968 | 29048 | 15.4% | -| 1 | `Txn` | `TxnByDevice` | `users_per_device_24h` | `device_id` | 2000 | 80 | 80 | 8 | 72 | 4392 | 4472 | 2.4% | -| 1 | `Txn` | `TxnByIp` | `users_per_ip_24h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 4392 | 4472 | 2.4% | -| 1 | `Txn` | `TxnByMerchant` | `users_per_merchant_24h` | `merchant_id` | 2000 | 80 | 80 | 8 | 72 | 4392 | 4472 | 2.4% | -| 1 | `Login` | `LoginByUser` | `ips_distinct_login_1h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | -| 1 | `Login` | `LoginByUser` | `uas_distinct_login_24h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | -| 1 | `Signup` | `SignupByIp` | `emails_per_ip_24h` | `ip_address` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | -| 1 | `Signup` | `SignupByIp` | `ssn_reuse_per_ip_30d` | `ip_address` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 0.1% | - -### 2. `top_k` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 2 | `Txn` | `TxnByUser` | `top_merchants_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 83264 | 83344 | 55.6% | -| 2 | `Txn` | `TxnByIp` | `ip_top_users` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 66440 | 66520 | 44.4% | - -### 3. `entropy` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 3 | `Txn` | `TxnByUser` | `mcc_entropy_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 72623 | 72703 | 100.0% | - -### 4. `event_type_mix` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 4 | `Txn` | `TxnByUser` | `event_mix_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 20608 | 20688 | 100.0% | - -### 5. `quantile` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 5 | `Txn` | `TxnByMerchant` | `merchant_amount_p99_24h` | `merchant_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | -| 5 | `Txn` | `TxnByUser` | `amount_p95_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | -| 5 | `Txn` | `TxnByUser` | `p50_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | -| 5 | `Txn` | `TxnByUser` | `p99_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 4464 | 4544 | 25.0% | - -### 6. `count` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 6 | `Txn` | `TxnByCard` | `decline_count_1h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByCard` | `txn_per_card_1h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByCard` | `txn_per_card_24h` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByDevice` | `device_txn_count_24h` | `device_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByIp` | `txn_per_ip_1h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByIp` | `txn_per_ip_24h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByMerchant` | `txn_per_merchant_24h` | `merchant_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByUser` | `txn_count_1h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByUser` | `txn_count_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `Txn` | `TxnByUser` | `txn_count_5m` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 7.2% | -| 6 | `CardAdd` | `CardAddByDevice` | `card_add_per_device_24h` | `device_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | -| 6 | `Login` | `LoginByUser` | `login_count_1h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | -| 6 | `Login` | `LoginByUser` | `login_count_24h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | -| 6 | `Refund` | `RefundByUser` | `refund_count_24h` | `user_id` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | -| 6 | `Signup` | `SignupByIp` | `signup_per_ip_24h` | `ip_address` | 0 | 80 | 80 | 8 | 72 | 176 | 256 | 5.5% | - -### 7. `burst_count` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 7 | `Txn` | `TxnByCard` | `small_amt_burst_5m` | `card_fp` | 2000 | 80 | 80 | 72 | 8 | 1024 | 1104 | 33.3% | -| 7 | `Txn` | `TxnByUser` | `burst_count_5m` | `user_id` | 2000 | 80 | 80 | 72 | 8 | 1024 | 1104 | 33.3% | -| 7 | `Signup` | `SignupByIp` | `signup_burst_10m` | `ip_address` | 0 | 80 | 80 | 72 | 8 | 1024 | 1104 | 33.3% | - -### 8. `distance_from_home` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 8 | `Txn` | `TxnByUser` | `dist_from_home` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 1720 | 1800 | 100.0% | - -### 9. `reservoir_sample` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 9 | `Txn` | `TxnByUser` | `reservoir_50` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 1600 | 1680 | 100.0% | - -### 10. `seasonal_deviation` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 10 | `Txn` | `TxnByUser` | `seasonal_dev` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 1427 | 1507 | 100.0% | - -### 11. `dow_hour_histogram` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 11 | `Txn` | `TxnByUser` | `dow_hour_hist_30d` | `user_id` | 2000 | 80 | 80 | 24 | 56 | 1344 | 1424 | 100.0% | - -### 12. `bloom_member` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 12 | `Txn` | `TxnByUser` | `device_seen` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 1280 | 1360 | 100.0% | - -### 13. `sum` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 13 | `Txn` | `TxnByIp` | `amount_sum_per_ip_1h` | `ip_address` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 50.0% | -| 13 | `Txn` | `TxnByUser` | `sum_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 50.0% | - -### 14. `geo_velocity` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 14 | `Txn` | `TxnByUser` | `geo_kmh` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 206 | 286 | 55.3% | -| 14 | `Login` | `LoginByUser` | `login_geo_kmh` | `user_id` | 0 | 80 | 80 | 8 | 72 | 151 | 231 | 44.7% | - -### 15. `n_unique` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 15 | `Txn` | `TxnByUser` | `unique_cells_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 168 | 248 | 50.0% | -| 15 | `CardAdd` | `CardAddByDevice` | `cards_per_device_lifetime` | `device_id` | 0 | 80 | 80 | 8 | 72 | 168 | 248 | 50.0% | - -### 16. `first_seen` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 16 | `Txn` | `TxnByCard` | `card_first_seen` | `card_fp` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByDevice` | `device_first_seen` | `device_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByIp` | `ip_first_seen` | `ip_address` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByMerchant` | `merchant_first_seen` | `merchant_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | -| 16 | `Txn` | `TxnByUser` | `first_seen` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 20.0% | - -### 17. `first_n` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 17 | `Txn` | `TxnByUser` | `first_5_merchants` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 256 | 336 | 100.0% | - -### 18. `mean` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 18 | `Txn` | `TxnByUser` | `avg_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | - -### 19. `min` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 19 | `Txn` | `TxnByUser` | `min_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | - -### 20. `std` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 20 | `Txn` | `TxnByUser` | `std_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | - -### 21. `var` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 21 | `Txn` | `TxnByUser` | `var_amount_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 256 | 336 | 100.0% | - -### 22. `hour_of_day_histogram` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 22 | `Txn` | `TxnByUser` | `hour_hist_30d` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 255 | 335 | 100.0% | - -### 23. `geo_spread` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 23 | `Txn` | `TxnByUser` | `geo_spread_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 250 | 330 | 100.0% | - -### 24. `age` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 24 | `Txn` | `TxnByCard` | `card_age` | `card_fp` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | -| 24 | `Txn` | `TxnByDevice` | `device_age` | `device_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | -| 24 | `Txn` | `TxnByIp` | `ip_age` | `ip_address` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | -| 24 | `Txn` | `TxnByUser` | `age` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 25.0% | - -### 25. `negative_streak` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 25 | `Txn` | `TxnByCard` | `decline_streak_card` | `card_fp` | 2000 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | -| 25 | `Txn` | `TxnByUser` | `decline_streak` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | -| 25 | `CardAdd` | `CardAddByDevice` | `card_add_failure_streak` | `device_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | -| 25 | `Login` | `LoginByUser` | `failed_login_streak` | `user_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 25.0% | - -### 26. `geo_distance` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 26 | `Txn` | `TxnByUser` | `geo_dist_last` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 192 | 272 | 100.0% | - -### 27. `count` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 27 | `Txn` | `TxnByUser` | `txn_count_lifetime` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 0 | 80 | 33.3% | -| 27 | `Refund` | `RefundByUser` | `chargeback_count_lifetime` | `user_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 33.3% | -| 27 | `Refund` | `RefundByUser` | `refund_count_lifetime` | `user_id` | 0 | 80 | 80 | 8 | 72 | 0 | 80 | 33.3% | - -### 28. `last_n` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 28 | `Txn` | `TxnByUser` | `last_5_amounts` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 160 | 240 | 100.0% | - -### 29. `last_seen` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 29 | `Txn` | `TxnByDevice` | `device_last_seen` | `device_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | -| 29 | `Txn` | `TxnByUser` | `last_seen` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | -| 29 | `Login` | `LoginByUser` | `last_login_at` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | - -### 30. `most_recent_n` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 30 | `Txn` | `TxnByUser` | `recent_5_amts` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 160 | 240 | 100.0% | - -### 31. `time_since` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 31 | `Txn` | `TxnByUser` | `time_since_last` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | -| 31 | `Login` | `LoginByUser` | `time_since_last_login` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | -| 31 | `Refund` | `RefundByUser` | `time_since_last_cb` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 33.3% | - -### 32. `decayed_count` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 32 | `Txn` | `TxnByUser` | `txn_decayed_count_24h` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 50.0% | -| 32 | `Refund` | `RefundByUser` | `chargeback_decayed_count` | `user_id` | 0 | 80 | 80 | 32 | 48 | 0 | 80 | 50.0% | - -### 33. `first_seen_in_window` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 33 | `Txn` | `TxnByUser` | `first_in_24h` | `user_id` | 2000 | 80 | 80 | 24 | 56 | 0 | 80 | 50.0% | -| 33 | `Refund` | `RefundByUser` | `first_refund_in_30d` | `user_id` | 0 | 80 | 80 | 24 | 56 | 0 | 80 | 50.0% | - -### 34. `streak` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 34 | `Txn` | `TxnByUser` | `txn_streak` | `user_id` | 2000 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | -| 34 | `Refund` | `RefundByUser` | `cb_streak` | `user_id` | 0 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | - -### 35. `sum` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 35 | `Txn` | `TxnByUser` | `sum_amount_lifetime` | `user_id` | 2000 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | -| 35 | `Refund` | `RefundByUser` | `refund_amount_lifetime` | `user_id` | 0 | 80 | 80 | 16 | 64 | 0 | 80 | 50.0% | - -### 36. `lag` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 36 | `Txn` | `TxnByUser` | `amount_lag1` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 64 | 144 | 100.0% | - -### 37. `entropy` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 37 | `Txn` | `TxnByUser` | `geo_entropy_24h` | `user_id` | 2000 | 80 | 80 | 8 | 72 | 56 | 136 | 100.0% | - -### 38. `time_since_last_n` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 38 | `Txn` | `TxnByUser` | `time_since_last_5` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 40 | 120 | 100.0% | - -### 39. `decayed_sum` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 39 | `Txn` | `TxnByUser` | `amount_decayed_sum_24h` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 40. `delta_from_prev` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 40 | `Txn` | `TxnByUser` | `amount_delta` | `user_id` | 2000 | 80 | 80 | 24 | 56 | 0 | 80 | 100.0% | - -### 41. `ew_zscore` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 41 | `Txn` | `TxnByUser` | `amount_ew_zscore` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 0 | 80 | 100.0% | - -### 42. `ewma` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 42 | `Txn` | `TxnByUser` | `amount_ewma_1h` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 43. `ewvar` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 43 | `Txn` | `TxnByUser` | `amount_ewvar_1h` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 0 | 80 | 100.0% | - -### 44. `first` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 44 | `Txn` | `TxnByUser` | `first_amount` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 45. `has_seen` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 45 | `Txn` | `TxnByUser` | `has_seen` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 46. `inter_arrival_stats` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 46 | `Txn` | `TxnByUser` | `inter_arrival_1h` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | - -### 47. `last` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 47 | `Txn` | `TxnByUser` | `last_amount` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 48. `max` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 48 | `Txn` | `TxnByUser` | `max_amount_lifetime` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 49. `max_streak` / `lifetime` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 49 | `Txn` | `TxnByUser` | `max_streak` | `user_id` | 2000 | 80 | 80 | 16 | 64 | 0 | 80 | 100.0% | - -### 50. `outlier_count` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 50 | `Txn` | `TxnByUser` | `amount_outliers_5m` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | - -### 51. `rate_of_change` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 51 | `Txn` | `TxnByUser` | `amount_rate_5m` | `user_id` | 2000 | 80 | 80 | 32 | 48 | 0 | 80 | 100.0% | - -### 52. `trend` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 52 | `Txn` | `TxnByUser` | `amount_trend_5m` | `user_id` | 2000 | 80 | 80 | 48 | 32 | 0 | 80 | 100.0% | - -### 53. `trend_residual` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 53 | `Txn` | `TxnByUser` | `amount_trend_resid_5m` | `user_id` | 2000 | 80 | 80 | 72 | 8 | 0 | 80 | 100.0% | - -### 54. `twa` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 54 | `Txn` | `TxnByUser` | `amount_twa_5m` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | - -### 55. `value_change_count` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 55 | `Txn` | `TxnByUser` | `device_change_count_5m` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | - -### 56. `z_score` / `windowed` paths - -| Parent rank | Source event | Derivation | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 56 | `Txn` | `TxnByUser` | `amount_z_score` | `user_id` | 2000 | 80 | 80 | 40 | 40 | 0 | 80 | 100.0% | +| 1 | `quantile` | `windowed` | 544720 | 544720 | 54472 | 490248 | 16450544 | 16995264 | +| 2 | `n_unique` | `windowed` | 888720 | 888720 | 88872 | 799848 | 4710216 | 5598936 | +| 3 | `count` | `windowed` | 956480 | 956480 | 95648 | 860832 | 3060736 | 4017216 | +| 4 | `distance_from_home` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 3409040 | 3567600 | +| 5 | `reservoir_sample` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 3171200 | 3329760 | +| 6 | `burst_count` | `windowed` | 226880 | 226880 | 204192 | 22688 | 2904064 | 3130944 | +| 7 | `seasonal_deviation` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 2823558 | 2982118 | +| 8 | `dow_hour_histogram` | `lifetime` | 158560 | 158560 | 47568 | 110992 | 2663808 | 2822368 | +| 9 | `bloom_member` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 2536960 | 2695520 | +| 10 | `top_k` | `windowed` | 227520 | 227520 | 22752 | 204768 | 1567104 | 1794624 | +| 11 | `sum` | `windowed` | 227520 | 227520 | 22752 | 204768 | 728064 | 955584 | +| 12 | `entropy` | `windowed` | 158560 | 158560 | 15856 | 142704 | 786164 | 944724 | +| 13 | `mean` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | +| 14 | `min` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | +| 15 | `std` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | +| 16 | `var` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | +| 17 | `hour_of_day_histogram` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 499464 | 658024 | +| 18 | `geo_spread` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 427321 | 585881 | +| 19 | `event_type_mix` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 413696 | 572256 | +| 20 | `geo_velocity` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 381469 | 540029 | +| 21 | `geo_distance` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 351735 | 510295 | +| 22 | `n_unique` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 332976 | 491536 | +| 23 | `last_n` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 317120 | 475680 | +| 24 | `most_recent_n` | `lifetime` | 158560 | 158560 | 95136 | 63424 | 317120 | 475680 | +| 25 | `first_seen` | `lifetime` | 433760 | 433760 | 173504 | 260256 | 0 | 433760 | +| 26 | `first_n` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 253696 | 412256 | +| 27 | `age` | `lifetime` | 364720 | 364720 | 145888 | 218832 | 0 | 364720 | +| 28 | `lag` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 126848 | 285408 | +| 29 | `entropy` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 110992 | 269552 | +| 30 | `time_since_last_n` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 79280 | 237840 | +| 31 | `last_seen` | `lifetime` | 227440 | 227440 | 90976 | 136464 | 0 | 227440 | +| 32 | `negative_streak` | `lifetime` | 226880 | 226880 | 22688 | 204192 | 0 | 226880 | +| 33 | `count` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 0 | 158560 | +| 34 | `decayed_count` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 35 | `decayed_sum` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 36 | `delta_from_prev` | `lifetime` | 158560 | 158560 | 47568 | 110992 | 0 | 158560 | +| 37 | `ew_zscore` | `lifetime` | 158560 | 158560 | 95136 | 63424 | 0 | 158560 | +| 38 | `ewma` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 39 | `ewvar` | `lifetime` | 158560 | 158560 | 95136 | 63424 | 0 | 158560 | +| 40 | `first` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 41 | `first_seen_in_window` | `windowed` | 158560 | 158560 | 47568 | 110992 | 0 | 158560 | +| 42 | `has_seen` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 43 | `inter_arrival_stats` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | +| 44 | `last` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 45 | `max` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 46 | `max_streak` | `lifetime` | 158560 | 158560 | 31712 | 126848 | 0 | 158560 | +| 47 | `outlier_count` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | +| 48 | `rate_of_change` | `windowed` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 49 | `streak` | `lifetime` | 158560 | 158560 | 31712 | 126848 | 0 | 158560 | +| 50 | `sum` | `lifetime` | 158560 | 158560 | 31712 | 126848 | 0 | 158560 | +| 51 | `time_since` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | +| 52 | `trend` | `windowed` | 158560 | 158560 | 95136 | 63424 | 0 | 158560 | +| 53 | `trend_residual` | `windowed` | 158560 | 158560 | 142704 | 15856 | 0 | 158560 | +| 54 | `twa` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | +| 55 | `value_change_count` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | +| 56 | `z_score` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | + +## Sorted Op Entity-Feature Details + +Secondary diagnostic view: top entity-feature contributors under each op/shape parent. The table/entity sections above are the primary bytes-per-entity view. + +### 1. `quantile` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 1 | `Txn` | `TxnByMerchant` | `s470` | `merchant_amount_p99_24h` | `merchant_id` | 9 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s176` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s278` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s387` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s507` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s570` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s707` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s825` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s12` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s172` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s201` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s365` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s371` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s39` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s498` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s537` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s591` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s643` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s655` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | +| 1 | `Txn` | `TxnByMerchant` | `s717` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | + +Showing top 20 of `6809` entity-feature rows for this op/shape. + +### 2. `n_unique` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 2 | `Txn` | `TxnByCard` | `s409` | `merchants_per_card_24h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s389` | `cards_per_ip_1h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s389` | `users_per_ip_24h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByMerchant` | `s470` | `users_per_merchant_24h` | `merchant_id` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s122` | `cards_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s122` | `users_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s466` | `cards_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s466` | `users_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByCard` | `s179` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByCard` | `s42` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByCard` | `s450` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByCard` | `s896` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByDevice` | `s377` | `cards_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByDevice` | `s377` | `users_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByDevice` | `s717` | `cards_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByDevice` | `s717` | `users_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByDevice` | `s743` | `cards_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByDevice` | `s743` | `users_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s132` | `cards_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | +| 2 | `Txn` | `TxnByIp` | `s132` | `users_per_ip_24h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | + +Showing top 20 of `11109` entity-feature rows for this op/shape. + +### 3. `count` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 3 | `Txn` | `TxnByCard` | `s409` | `decline_count_1h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s409` | `txn_per_card_1h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s409` | `txn_per_card_24h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByIp` | `s389` | `txn_per_ip_1h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByIp` | `s389` | `txn_per_ip_24h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByMerchant` | `s470` | `txn_per_merchant_24h` | `merchant_id` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByIp` | `s122` | `txn_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByIp` | `s122` | `txn_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByIp` | `s466` | `txn_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByIp` | `s466` | `txn_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s179` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s179` | `txn_per_card_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s179` | `txn_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s42` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s42` | `txn_per_card_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s42` | `txn_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s450` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s450` | `txn_per_card_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s450` | `txn_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 3 | `Txn` | `TxnByCard` | `s896` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | + +Showing top 20 of `11956` entity-feature rows for this op/shape. + +### 4. `distance_from_home` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 4 | `Txn` | `TxnByUser` | `k00013835` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00017893` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00022821` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00029943` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00030706` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00030832` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00031894` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00039938` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00041244` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00041440` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00042338` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00046226` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00053345` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00055008` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00064964` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00067574` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00070333` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00089428` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00000032` | `dist_from_home` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | +| 4 | `Txn` | `TxnByUser` | `k00000045` | `dist_from_home` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 5. `reservoir_sample` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 5 | `Txn` | `TxnByUser` | `k00013835` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00017893` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00022821` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00029943` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00030706` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00030832` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00031894` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00039938` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00041244` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00041440` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00042338` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00046226` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00053345` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00055008` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00064964` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00067574` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00070333` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00089428` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00000032` | `reservoir_50` | `user_id` | 1 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | +| 5 | `Txn` | `TxnByUser` | `k00000045` | `reservoir_50` | `user_id` | 1 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 6. `burst_count` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 6 | `Txn` | `TxnByCard` | `s409` | `small_amt_burst_5m` | `card_fp` | 10 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s179` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s42` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s450` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s896` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s138` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s274` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s337` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s354` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s433` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s474` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s555` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s560` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s566` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s654` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s770` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s957` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s996` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s129` | `small_amt_burst_5m` | `card_fp` | 5 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | +| 6 | `Txn` | `TxnByCard` | `s150` | `small_amt_burst_5m` | `card_fp` | 5 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | + +Showing top 20 of `2836` entity-feature rows for this op/shape. + +### 7. `seasonal_deviation` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 7 | `Txn` | `TxnByUser` | `k00000181` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00000870` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00001150` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00001671` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00001874` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00001952` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00002108` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00002920` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00003254` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00003623` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00004116` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00004151` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00004200` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00004653` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00005051` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00005603` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00006199` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00006234` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00006914` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | +| 7 | `Txn` | `TxnByUser` | `k00007171` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 8. `dow_hour_histogram` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 8 | `Txn` | `TxnByUser` | `k00013835` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00017893` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00022821` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00029943` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00030706` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00030832` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00031894` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00039938` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00041244` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00041440` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00042338` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00046226` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00053345` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00055008` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00064964` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00067574` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00070333` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00089428` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00000032` | `dow_hour_hist_30d` | `user_id` | 1 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | +| 8 | `Txn` | `TxnByUser` | `k00000045` | `dow_hour_hist_30d` | `user_id` | 1 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 9. `bloom_member` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 9 | `Txn` | `TxnByUser` | `k00013835` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00017893` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00022821` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00029943` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00030706` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00030832` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00031894` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00039938` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00041244` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00041440` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00042338` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00046226` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00053345` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00055008` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00064964` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00067574` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00070333` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00089428` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00000032` | `device_seen` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 9 | `Txn` | `TxnByUser` | `k00000045` | `device_seen` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 10. `top_k` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 10 | `Txn` | `TxnByIp` | `s389` | `ip_top_users` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s122` | `ip_top_users` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 1184 | 1264 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s466` | `ip_top_users` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 1184 | 1264 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s132` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s226` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s683` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s789` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s108` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s140` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s161` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s225` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s227` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s279` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s486` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s629` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s681` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s69` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s780` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s825` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | +| 10 | `Txn` | `TxnByIp` | `s928` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | + +Showing top 20 of `2844` entity-feature rows for this op/shape. + +### 11. `sum` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 11 | `Txn` | `TxnByIp` | `s389` | `amount_sum_per_ip_1h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s122` | `amount_sum_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s466` | `amount_sum_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s132` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s226` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s683` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s789` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s108` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s140` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s161` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s225` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s227` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s279` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s486` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s629` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s681` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s69` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s780` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s825` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | +| 11 | `Txn` | `TxnByIp` | `s928` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | + +Showing top 20 of `2844` entity-feature rows for this op/shape. + +### 12. `entropy` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 12 | `Txn` | `TxnByUser` | `k00013835` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00017893` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00022821` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00029943` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00030706` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00030832` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00031894` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00041244` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00042338` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00046226` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00053345` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00055008` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00064964` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00067574` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00070333` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00089428` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00039938` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 479 | 559 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00041440` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 479 | 559 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00000032` | `mcc_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 396 | 476 | 0.1% | +| 12 | `Txn` | `TxnByUser` | `k00000045` | `mcc_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 396 | 476 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 13. `mean` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 13 | `Txn` | `TxnByUser` | `k00013835` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00017893` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00022821` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00029943` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00030706` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00030832` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00031894` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00039938` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00041244` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00041440` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00042338` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00046226` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00053345` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00055008` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00064964` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00067574` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00070333` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00089428` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00000032` | `avg_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 13 | `Txn` | `TxnByUser` | `k00000045` | `avg_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 14. `min` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 14 | `Txn` | `TxnByUser` | `k00013835` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00017893` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00022821` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00029943` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00030706` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00030832` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00031894` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00039938` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00041244` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00041440` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00042338` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00046226` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00053345` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00055008` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00064964` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00067574` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00070333` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00089428` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00000032` | `min_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 14 | `Txn` | `TxnByUser` | `k00000045` | `min_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 15. `std` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 15 | `Txn` | `TxnByUser` | `k00013835` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00017893` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00022821` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00029943` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00030706` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00030832` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00031894` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00039938` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00041244` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00041440` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00042338` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00046226` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00053345` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00055008` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00064964` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00067574` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00070333` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00089428` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00000032` | `std_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 15 | `Txn` | `TxnByUser` | `k00000045` | `std_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 16. `var` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 16 | `Txn` | `TxnByUser` | `k00013835` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00017893` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00022821` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00029943` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00030706` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00030832` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00031894` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00039938` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00041244` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00041440` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00042338` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00046226` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00053345` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00055008` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00064964` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00067574` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00070333` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00089428` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00000032` | `var_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | +| 16 | `Txn` | `TxnByUser` | `k00000045` | `var_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 17. `hour_of_day_histogram` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 17 | `Txn` | `TxnByUser` | `k00013835` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00017893` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00022821` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00029943` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00030706` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00030832` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00031894` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00039938` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00041244` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00041440` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00042338` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00046226` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00053345` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00055008` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00064964` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00067574` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00070333` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00089428` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00000032` | `hour_hist_30d` | `user_id` | 1 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | +| 17 | `Txn` | `TxnByUser` | `k00000045` | `hour_hist_30d` | `user_id` | 1 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 18. `geo_spread` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 18 | `Txn` | `TxnByUser` | `k00029943` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 246 | 326 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00013835` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00022821` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00041244` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00041440` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00042338` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00046226` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00055008` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00070333` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00017893` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00030706` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00031894` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00039938` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00064964` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00067574` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00089428` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00030832` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 243 | 323 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00053345` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 243 | 323 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00000113` | `geo_spread_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 217 | 297 | 0.1% | +| 18 | `Txn` | `TxnByUser` | `k00001471` | `geo_spread_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 217 | 297 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 19. `event_type_mix` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 19 | `Txn` | `TxnByUser` | `k00013835` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00017893` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00022821` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00029943` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00030706` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00030832` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00031894` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00039938` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00041244` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00041440` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00042338` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00046226` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00053345` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00055008` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00064964` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00067574` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00070333` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00089428` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00000032` | `event_mix_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | +| 19 | `Txn` | `TxnByUser` | `k00000045` | `event_mix_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 20. `geo_velocity` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 20 | `Txn` | `TxnByUser` | `k00055008` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 209 | 289 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00029943` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00067574` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00070333` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00017893` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00022821` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00030706` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00039938` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00053345` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00013835` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00030832` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00031894` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00041440` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00042338` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00046226` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00064964` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00089428` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00041244` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 204 | 284 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00000113` | `geo_kmh` | `user_id` | 1 | 80 | 80 | 8 | 72 | 194 | 274 | 0.1% | +| 20 | `Txn` | `TxnByUser` | `k00001471` | `geo_kmh` | `user_id` | 1 | 80 | 80 | 8 | 72 | 194 | 274 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 21. `geo_distance` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 21 | `Txn` | `TxnByUser` | `k00029943` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00055008` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00067574` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00070333` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00030706` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 192 | 272 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00046226` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 192 | 272 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00053345` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 192 | 272 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00013835` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00017893` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00022821` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00031894` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00039938` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00041440` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00042338` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00064964` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00089428` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00030832` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 190 | 270 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00041244` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 189 | 269 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00000113` | `geo_dist_last` | `user_id` | 1 | 80 | 80 | 8 | 72 | 179 | 259 | 0.1% | +| 21 | `Txn` | `TxnByUser` | `k00001471` | `geo_dist_last` | `user_id` | 1 | 80 | 80 | 8 | 72 | 179 | 259 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 22. `n_unique` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 22 | `Txn` | `TxnByUser` | `k00013835` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00017893` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00022821` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00029943` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00030706` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00030832` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00031894` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00039938` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00041244` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00041440` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00042338` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00046226` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00053345` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00055008` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00064964` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00067574` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00070333` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00089428` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00000032` | `unique_cells_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | +| 22 | `Txn` | `TxnByUser` | `k00000045` | `unique_cells_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 23. `last_n` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 23 | `Txn` | `TxnByUser` | `k00013835` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00017893` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00022821` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00029943` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00030706` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00030832` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00031894` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00039938` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00041244` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00041440` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00042338` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00046226` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00053345` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00055008` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00064964` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00067574` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00070333` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00089428` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00000032` | `last_5_amounts` | `user_id` | 1 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | +| 23 | `Txn` | `TxnByUser` | `k00000045` | `last_5_amounts` | `user_id` | 1 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 24. `most_recent_n` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 24 | `Txn` | `TxnByUser` | `k00013835` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00017893` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00022821` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00029943` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00030706` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00030832` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00031894` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00039938` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00041244` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00041440` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00042338` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00046226` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00053345` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00055008` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00064964` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00067574` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00070333` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00089428` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00000032` | `recent_5_amts` | `user_id` | 1 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | +| 24 | `Txn` | `TxnByUser` | `k00000045` | `recent_5_amts` | `user_id` | 1 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 25. `first_seen` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 25 | `Txn` | `TxnByCard` | `s409` | `card_first_seen` | `card_fp` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s389` | `ip_first_seen` | `ip_address` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByMerchant` | `s470` | `merchant_first_seen` | `merchant_id` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s122` | `ip_first_seen` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s466` | `ip_first_seen` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByCard` | `s179` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByCard` | `s42` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByCard` | `s450` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByCard` | `s896` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByDevice` | `s377` | `device_first_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByDevice` | `s717` | `device_first_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByDevice` | `s743` | `device_first_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s132` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s226` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s683` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByIp` | `s789` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByMerchant` | `s176` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByMerchant` | `s278` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByMerchant` | `s387` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 25 | `Txn` | `TxnByMerchant` | `s507` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | + +Showing top 20 of `5422` entity-feature rows for this op/shape. + +### 26. `first_n` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 26 | `Txn` | `TxnByUser` | `k00013835` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00017893` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00022821` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00029943` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00030706` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00030832` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00031894` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00039938` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00041244` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00041440` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00042338` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00046226` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00053345` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00055008` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00064964` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00067574` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00070333` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00089428` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00000032` | `first_5_merchants` | `user_id` | 1 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | +| 26 | `Txn` | `TxnByUser` | `k00000045` | `first_5_merchants` | `user_id` | 1 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 27. `age` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 27 | `Txn` | `TxnByCard` | `s409` | `card_age` | `card_fp` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s389` | `ip_age` | `ip_address` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s122` | `ip_age` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s466` | `ip_age` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s179` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s42` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s450` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s896` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByDevice` | `s377` | `device_age` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByDevice` | `s717` | `device_age` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByDevice` | `s743` | `device_age` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s132` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s226` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s683` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByIp` | `s789` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s138` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s274` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s337` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s354` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 27 | `Txn` | `TxnByCard` | `s433` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | + +Showing top 20 of `4559` entity-feature rows for this op/shape. + +### 28. `lag` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 28 | `Txn` | `TxnByUser` | `k00013835` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00017893` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00022821` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00029943` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00030706` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00030832` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00031894` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00039938` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00041244` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00041440` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00042338` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00046226` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00053345` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00055008` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00064964` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00067574` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00070333` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00089428` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00000032` | `amount_lag1` | `user_id` | 1 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | +| 28 | `Txn` | `TxnByUser` | `k00000045` | `amount_lag1` | `user_id` | 1 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 29. `entropy` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 29 | `Txn` | `TxnByUser` | `k00013835` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00017893` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00022821` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00029943` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00030706` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00030832` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00031894` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00039938` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00041244` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00041440` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00042338` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00046226` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00053345` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00055008` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00064964` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00067574` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00070333` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00089428` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00000032` | `geo_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | +| 29 | `Txn` | `TxnByUser` | `k00000045` | `geo_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 30. `time_since_last_n` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 30 | `Txn` | `TxnByUser` | `k00013835` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00017893` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00022821` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00029943` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00030706` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00030832` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00031894` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00039938` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00041244` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00041440` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00042338` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00046226` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00053345` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00055008` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00064964` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00067574` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00070333` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00089428` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00000032` | `time_since_last_5` | `user_id` | 1 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | +| 30 | `Txn` | `TxnByUser` | `k00000045` | `time_since_last_5` | `user_id` | 1 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 31. `last_seen` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 31 | `Txn` | `TxnByDevice` | `s377` | `device_last_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s717` | `device_last_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s743` | `device_last_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s107` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s171` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s469` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s519` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s586` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s632` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s66` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s846` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s903` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s955` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s959` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s960` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s994` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s116` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s118` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s136` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | +| 31 | `Txn` | `TxnByDevice` | `s177` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | + +Showing top 20 of `2843` entity-feature rows for this op/shape. + +### 32. `negative_streak` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 32 | `Txn` | `TxnByCard` | `s409` | `decline_streak_card` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s179` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s42` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s450` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s896` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s138` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s274` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s337` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s354` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s433` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s474` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s555` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s560` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s566` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s654` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s770` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s957` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s996` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s129` | `decline_streak_card` | `card_fp` | 5 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | +| 32 | `Txn` | `TxnByCard` | `s150` | `decline_streak_card` | `card_fp` | 5 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | + +Showing top 20 of `2836` entity-feature rows for this op/shape. + +### 33. `count` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 33 | `Txn` | `TxnByUser` | `k00013835` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00017893` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00022821` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00029943` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00030706` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00030832` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00031894` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00039938` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00041244` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00041440` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00042338` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00046226` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00053345` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00055008` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00064964` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00067574` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00070333` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00089428` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00000032` | `txn_count_lifetime` | `user_id` | 1 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | +| 33 | `Txn` | `TxnByUser` | `k00000045` | `txn_count_lifetime` | `user_id` | 1 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 34. `decayed_count` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 34 | `Txn` | `TxnByUser` | `k00013835` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00017893` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00022821` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00029943` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00030706` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00030832` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00031894` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00039938` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00041244` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00041440` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00042338` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00046226` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00053345` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00055008` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00064964` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00067574` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00070333` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00089428` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00000032` | `txn_decayed_count_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 34 | `Txn` | `TxnByUser` | `k00000045` | `txn_decayed_count_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 35. `decayed_sum` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 35 | `Txn` | `TxnByUser` | `k00013835` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00017893` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00022821` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00029943` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00030706` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00030832` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00031894` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00039938` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00041244` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00041440` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00042338` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00046226` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00053345` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00055008` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00064964` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00067574` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00070333` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00089428` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00000032` | `amount_decayed_sum_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 35 | `Txn` | `TxnByUser` | `k00000045` | `amount_decayed_sum_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 36. `delta_from_prev` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 36 | `Txn` | `TxnByUser` | `k00013835` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00017893` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00022821` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00029943` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00030706` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00030832` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00031894` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00039938` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00041244` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00041440` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00042338` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00046226` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00053345` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00055008` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00064964` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00067574` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00070333` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00089428` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00000032` | `amount_delta` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 36 | `Txn` | `TxnByUser` | `k00000045` | `amount_delta` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 37. `ew_zscore` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 37 | `Txn` | `TxnByUser` | `k00013835` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00017893` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00022821` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00029943` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00030706` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00030832` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00031894` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00039938` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00041244` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00041440` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00042338` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00046226` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00053345` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00055008` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00064964` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00067574` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00070333` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00089428` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00000032` | `amount_ew_zscore` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 37 | `Txn` | `TxnByUser` | `k00000045` | `amount_ew_zscore` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 38. `ewma` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 38 | `Txn` | `TxnByUser` | `k00013835` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00017893` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00022821` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00029943` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00030706` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00030832` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00031894` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00039938` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00041244` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00041440` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00042338` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00046226` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00053345` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00055008` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00064964` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00067574` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00070333` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00089428` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00000032` | `amount_ewma_1h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 38 | `Txn` | `TxnByUser` | `k00000045` | `amount_ewma_1h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 39. `ewvar` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 39 | `Txn` | `TxnByUser` | `k00013835` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00017893` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00022821` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00029943` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00030706` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00030832` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00031894` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00039938` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00041244` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00041440` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00042338` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00046226` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00053345` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00055008` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00064964` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00067574` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00070333` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00089428` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00000032` | `amount_ewvar_1h` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 39 | `Txn` | `TxnByUser` | `k00000045` | `amount_ewvar_1h` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 40. `first` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 40 | `Txn` | `TxnByUser` | `k00013835` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00017893` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00022821` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00029943` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00030706` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00030832` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00031894` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00039938` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00041244` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00041440` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00042338` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00046226` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00053345` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00055008` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00064964` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00067574` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00070333` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00089428` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00000032` | `first_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 40 | `Txn` | `TxnByUser` | `k00000045` | `first_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 41. `first_seen_in_window` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 41 | `Txn` | `TxnByUser` | `k00013835` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00017893` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00022821` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00029943` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00030706` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00030832` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00031894` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00039938` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00041244` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00041440` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00042338` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00046226` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00053345` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00055008` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00064964` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00067574` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00070333` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00089428` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00000032` | `first_in_24h` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | +| 41 | `Txn` | `TxnByUser` | `k00000045` | `first_in_24h` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 42. `has_seen` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 42 | `Txn` | `TxnByUser` | `k00013835` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00017893` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00022821` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00029943` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00030706` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00030832` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00031894` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00039938` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00041244` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00041440` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00042338` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00046226` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00053345` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00055008` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00064964` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00067574` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00070333` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00089428` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00000032` | `has_seen` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 42 | `Txn` | `TxnByUser` | `k00000045` | `has_seen` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 43. `inter_arrival_stats` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 43 | `Txn` | `TxnByUser` | `k00013835` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00017893` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00022821` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00029943` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00030706` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00030832` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00031894` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00039938` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00041244` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00041440` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00042338` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00046226` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00053345` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00055008` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00064964` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00067574` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00070333` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00089428` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00000032` | `inter_arrival_1h` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 43 | `Txn` | `TxnByUser` | `k00000045` | `inter_arrival_1h` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 44. `last` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 44 | `Txn` | `TxnByUser` | `k00013835` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00017893` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00022821` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00029943` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00030706` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00030832` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00031894` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00039938` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00041244` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00041440` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00042338` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00046226` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00053345` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00055008` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00064964` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00067574` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00070333` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00089428` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00000032` | `last_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 44 | `Txn` | `TxnByUser` | `k00000045` | `last_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 45. `max` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 45 | `Txn` | `TxnByUser` | `k00013835` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00017893` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00022821` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00029943` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00030706` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00030832` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00031894` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00039938` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00041244` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00041440` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00042338` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00046226` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00053345` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00055008` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00064964` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00067574` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00070333` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00089428` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00000032` | `max_amount_lifetime` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 45 | `Txn` | `TxnByUser` | `k00000045` | `max_amount_lifetime` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 46. `max_streak` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 46 | `Txn` | `TxnByUser` | `k00013835` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00017893` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00022821` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00029943` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00030706` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00030832` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00031894` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00039938` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00041244` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00041440` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00042338` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00046226` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00053345` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00055008` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00064964` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00067574` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00070333` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00089428` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00000032` | `max_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 46 | `Txn` | `TxnByUser` | `k00000045` | `max_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 47. `outlier_count` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 47 | `Txn` | `TxnByUser` | `k00013835` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00017893` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00022821` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00029943` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00030706` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00030832` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00031894` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00039938` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00041244` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00041440` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00042338` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00046226` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00053345` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00055008` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00064964` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00067574` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00070333` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00089428` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00000032` | `amount_outliers_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 47 | `Txn` | `TxnByUser` | `k00000045` | `amount_outliers_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 48. `rate_of_change` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 48 | `Txn` | `TxnByUser` | `k00013835` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00017893` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00022821` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00029943` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00030706` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00030832` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00031894` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00039938` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00041244` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00041440` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00042338` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00046226` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00053345` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00055008` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00064964` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00067574` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00070333` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00089428` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00000032` | `amount_rate_5m` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 48 | `Txn` | `TxnByUser` | `k00000045` | `amount_rate_5m` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 49. `streak` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 49 | `Txn` | `TxnByUser` | `k00013835` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00017893` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00022821` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00029943` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00030706` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00030832` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00031894` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00039938` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00041244` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00041440` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00042338` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00046226` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00053345` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00055008` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00064964` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00067574` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00070333` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00089428` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00000032` | `txn_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 49 | `Txn` | `TxnByUser` | `k00000045` | `txn_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 50. `sum` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 50 | `Txn` | `TxnByUser` | `k00013835` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00017893` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00022821` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00029943` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00030706` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00030832` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00031894` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00039938` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00041244` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00041440` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00042338` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00046226` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00053345` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00055008` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00064964` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00067574` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00070333` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00089428` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00000032` | `sum_amount_lifetime` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | +| 50 | `Txn` | `TxnByUser` | `k00000045` | `sum_amount_lifetime` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 51. `time_since` / `lifetime` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 51 | `Txn` | `TxnByUser` | `k00013835` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00017893` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00022821` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00029943` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00030706` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00030832` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00031894` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00039938` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00041244` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00041440` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00042338` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00046226` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00053345` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00055008` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00064964` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00067574` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00070333` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00089428` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00000032` | `time_since_last` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | +| 51 | `Txn` | `TxnByUser` | `k00000045` | `time_since_last` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 52. `trend` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 52 | `Txn` | `TxnByUser` | `k00013835` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00017893` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00022821` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00029943` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00030706` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00030832` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00031894` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00039938` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00041244` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00041440` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00042338` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00046226` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00053345` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00055008` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00064964` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00067574` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00070333` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00089428` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00000032` | `amount_trend_5m` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | +| 52 | `Txn` | `TxnByUser` | `k00000045` | `amount_trend_5m` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 53. `trend_residual` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 53 | `Txn` | `TxnByUser` | `k00013835` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00017893` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00022821` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00029943` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00030706` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00030832` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00031894` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00039938` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00041244` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00041440` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00042338` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00046226` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00053345` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00055008` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00064964` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00067574` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00070333` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00089428` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00000032` | `amount_trend_resid_5m` | `user_id` | 1 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | +| 53 | `Txn` | `TxnByUser` | `k00000045` | `amount_trend_resid_5m` | `user_id` | 1 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 54. `twa` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 54 | `Txn` | `TxnByUser` | `k00013835` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00017893` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00022821` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00029943` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00030706` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00030832` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00031894` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00039938` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00041244` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00041440` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00042338` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00046226` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00053345` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00055008` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00064964` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00067574` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00070333` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00089428` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00000032` | `amount_twa_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 54 | `Txn` | `TxnByUser` | `k00000045` | `amount_twa_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 55. `value_change_count` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 55 | `Txn` | `TxnByUser` | `k00013835` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00017893` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00022821` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00029943` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00030706` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00030832` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00031894` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00039938` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00041244` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00041440` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00042338` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00046226` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00053345` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00055008` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00064964` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00067574` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00070333` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00089428` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00000032` | `device_change_count_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 55 | `Txn` | `TxnByUser` | `k00000045` | `device_change_count_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. + +### 56. `z_score` / `windowed` entity-feature rows + +| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | +|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| +| 56 | `Txn` | `TxnByUser` | `k00013835` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00017893` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00022821` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00029943` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00030706` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00030832` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00031894` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00039938` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00041244` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00041440` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00042338` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00046226` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00053345` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00055008` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00064964` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00067574` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00070333` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00089428` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00000032` | `amount_z_score` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | +| 56 | `Txn` | `TxnByUser` | `k00000045` | `amount_z_score` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | + +Showing top 20 of `1982` entity-feature rows for this op/shape. ## Top 5 Offenders -### 1. `Txn` / `TxnByUser` / `top_merchants_24h` / `top_k` +### 1. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` -- Path: `Txn` -> `TxnByUser` -> `top_merchants_24h` -> `top_k` -> `windowed` -- Key path: `user_id` -- Events applied: `2000` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=83264 total=83344 +- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` +- Entity key: `s470` +- Entity events: `9` +- Key path: `merchant_id` +- Events applied: `9` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `TopK exact BTreeMap entries across buckets`: 82848 bytes (BTreeMap, summed across active window buckets) + - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 160 bytes (Box, summed across active window buckets) + - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - Raw breakdown: - - `Windowed bucket 0 / TopK exact BTreeMap entries`: 82848 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) + - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) -### 2. `Txn` / `TxnByUser` / `mcc_entropy_24h` / `entropy` +### 2. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` -- Path: `Txn` -> `TxnByUser` -> `mcc_entropy_24h` -> `entropy` -> `windowed` -- Key path: `user_id` -- Events applied: `2000` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=72623 total=72703 +- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` +- Entity key: `s176` +- Entity events: `7` +- Key path: `merchant_id` +- Events applied: `7` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `Entropy category map entries across buckets`: 68960 bytes (BTreeMap, summed across active window buckets) - - `Entropy category string capacity across buckets`: 3351 bytes (String, summed across active window buckets) + - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 56 bytes (Box, summed across active window buckets) - Raw breakdown: - - `Windowed bucket 0 / Entropy category map entries`: 68960 bytes (BTreeMap, estimated node overhead plus String/u64 category payloads) - - `Windowed bucket 0 / Entropy category string capacity`: 3351 bytes (String, sum of tracked category string capacities) + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 0 / Box`: 56 bytes (Box, heap allocation for boxed Entropy wrapper) -### 3. `Txn` / `TxnByIp` / `ip_top_users` / `top_k` +### 3. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` -- Path: `Txn` -> `TxnByIp` -> `ip_top_users` -> `top_k` -> `windowed` -- Key path: `ip_address` -- Events applied: `2000` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=66440 total=66520 +- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` +- Entity key: `s278` +- Entity events: `7` +- Key path: `merchant_id` +- Events applied: `7` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) - Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `TopK count-min counters across buckets`: 65536 bytes (Vec, summed across active window buckets) - - `TopK heap index map across buckets`: 392 bytes (AHashMap, summed across active window buckets) + - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 160 bytes (Box, summed across active window buckets) - - `TopK heap entries across buckets`: 96 bytes (Vec, summed across active window buckets) + - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - Raw breakdown: - - `Windowed bucket 0 / TopK count-min counters`: 65536 bytes (Vec, capacity * size_of::() for count-min sketch counters) - - `Windowed bucket 0 / TopK heap index map`: 392 bytes (AHashMap, estimated slot cost for TopK heap-position side index) + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - - `Windowed bucket 0 / TopK heap entries`: 96 bytes (Vec, capacity * size_of::<(u64, TopKValue)>() for bounded top-k heap entries) + - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) -### 4. `Txn` / `TxnByCard` / `merchants_per_card_24h` / `n_unique` +### 4. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` -- Path: `Txn` -> `TxnByCard` -> `merchants_per_card_24h` -> `n_unique` -> `windowed` -- Key path: `card_fp` -- Events applied: `2000` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=28968 total=29048 +- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` +- Entity key: `s387` +- Entity events: `7` +- Key path: `merchant_id` +- Events applied: `7` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) -- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 28672 bytes (HashSet, summed across active window buckets) + - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 40 bytes (Box, summed across active window buckets) - Raw breakdown: - - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) -### 5. `Txn` / `TxnByDevice` / `cards_per_device_24h` / `n_unique` +### 5. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` -- Path: `Txn` -> `TxnByDevice` -> `cards_per_device_24h` -> `n_unique` -> `windowed` -- Key path: `device_id` -- Events applied: `2000` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=28968 total=29048 +- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` +- Entity key: `s507` +- Entity events: `7` +- Key path: `merchant_id` +- Events applied: `7` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) -- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately +- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 28672 bytes (HashSet, summed across active window buckets) + - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) + - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 40 bytes (Box, summed across active window buckets) - Raw breakdown: - - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) + - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) ## Metrics Coherence - `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile per-entity estimate: `474904` bytes +- Profile bytes-per-active-entity-row p99: `26655` bytes - Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 467904 bytes; file sibling work to replace the static placeholder with live sampling. +- Assertion: bytes_per_entity_p99 diverged by 19655 bytes; file sibling work to replace the static placeholder with live sampling. ## Notes @@ -584,4 +2028,4 @@ Rows with `0` events applied show constructor footprint only; the workload gener - `payload_bytes` is the active variant payload inside the enum slot. For boxed variants this is the inline `Box` pointer, while the boxed pointee remains in `heap_bytes`. - `slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot: `enum_slot_bytes - payload_bytes`. - Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. -- Path grain is `source_event -> derivation -> feature -> op -> shape`; path detail rows are children of the op/shape rollups above. +- Primary grain is `derivation table -> entity row -> feature column`; op/shape rows remain as secondary diagnostics for implementation-level hotspots. From 029bfa2bac448b6e95d6909a90bb76945ed0ae4c Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Thu, 21 May 2026 22:12:33 -0400 Subject: [PATCH 6/9] Removed bloated sections --- crates/beava-bench/src/bin/memprofile.rs | 121 +- crates/beava-bench/tests/memprofile_smoke.rs | 11 +- memory-profile-fraud-team.md | 1577 ------------------ 3 files changed, 7 insertions(+), 1702 deletions(-) diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs index e7da4879..10ab72c6 100644 --- a/crates/beava-bench/src/bin/memprofile.rs +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -66,14 +66,6 @@ impl ProfileShape { } } -#[derive(Debug, Clone)] -struct OpTotal { - op_name: String, - shape: ProfileShape, - profile: MemProfile, - rows: Vec, -} - struct ReportInput<'a> { workload: &'a str, events_requested: u64, @@ -84,7 +76,6 @@ struct ReportInput<'a> { active_entity_count: usize, table_profiles: &'a [TableProfile], rows: &'a [ProfileRow], - op_totals: &'a [OpTotal], bytes_per_entity_p99: usize, metrics_placeholder: u64, tolerance: f64, @@ -226,42 +217,6 @@ fn build_report(args: &Args) -> Result { rows.sort_by(compare_profile_rows); - let mut grouped: BTreeMap<(String, ProfileShape), Vec> = BTreeMap::new(); - for row in &rows { - grouped - .entry((row.op_name.clone(), row.shape)) - .or_default() - .push(row.clone()); - } - let mut op_totals: Vec = grouped - .into_iter() - .map(|((op_name, shape), mut rows)| { - let mut total = MemProfile::new(op_name.clone(), 0); - for row in &rows { - total.stack_bytes += row.profile.stack_bytes; - total.enum_slot_bytes += row.profile.enum_slot_bytes; - total.payload_bytes += row.profile.payload_bytes; - total.slack_bytes += row.profile.slack_bytes; - total.heap_bytes += row.profile.heap_bytes; - total.breakdown.extend(row.profile.breakdown.clone()); - } - rows.sort_by(compare_profile_rows); - OpTotal { - op_name, - shape, - profile: total, - rows, - } - }) - .collect(); - op_totals.sort_by(|a, b| { - b.profile - .total_bytes() - .cmp(&a.profile.total_bytes()) - .then_with(|| a.op_name.cmp(&b.op_name)) - .then_with(|| a.shape.cmp(&b.shape)) - }); - table_profiles.sort_by(compare_table_profiles); let active_entity_count = table_profiles.iter().map(|t| t.active_entities).sum(); let all_entity_totals = table_profiles @@ -284,7 +239,6 @@ fn build_report(args: &Args) -> Result { active_entity_count, table_profiles: &table_profiles, rows: &rows, - op_totals: &op_totals, bytes_per_entity_p99, metrics_placeholder: args.metrics_bytes_per_entity_p99, tolerance: args.tolerance, @@ -431,63 +385,6 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push('\n'); } - out.push_str("## Sorted Op Table\n\n"); - out.push_str("| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes |\n"); - out.push_str("|------|----|-------|-------------|-----------------|---------------|-------------|------------|-------------|\n"); - for (idx, profile) in input.op_totals.iter().enumerate() { - out.push_str(&format!( - "| {} | `{}` | `{}` | {} | {} | {} | {} | {} | {} |\n", - idx + 1, - profile.op_name, - profile.shape.as_str(), - profile.profile.stack_bytes, - profile.profile.enum_slot_bytes, - profile.profile.payload_bytes, - profile.profile.slack_bytes, - profile.profile.heap_bytes, - profile.profile.total_bytes() - )); - } - - out.push_str("\n## Sorted Op Entity-Feature Details\n\n"); - out.push_str("Secondary diagnostic view: top entity-feature contributors under each op/shape parent. The table/entity sections above are the primary bytes-per-entity view.\n\n"); - for (idx, total) in input.op_totals.iter().enumerate() { - out.push_str(&format!( - "### {}. `{}` / `{}` entity-feature rows\n\n", - idx + 1, - total.op_name, - total.shape.as_str() - )); - out.push_str("| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % |\n"); - out.push_str("|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------|\n"); - for row in total.rows.iter().take(20) { - out.push_str(&format!( - "| {} | `{}` | `{}` | `{}` | `{}` | `{}` | {} | {} | {} | {} | {} | {} | {} | {:.1}% |\n", - idx + 1, - format_sources(&row.source_events), - row.derivation, - row.entity_key, - row.feature, - format_key_path(&row.key_path), - row.events_applied, - row.profile.stack_bytes, - row.profile.enum_slot_bytes, - row.profile.payload_bytes, - row.profile.slack_bytes, - row.profile.heap_bytes, - row.profile.total_bytes(), - percent_of(row.profile.total_bytes(), total.profile.total_bytes()) - )); - } - if total.rows.len() > 20 { - out.push_str(&format!( - "\nShowing top 20 of `{}` entity-feature rows for this op/shape.\n", - total.rows.len() - )); - } - out.push('\n'); - } - out.push_str("## Top 5 Offenders\n\n"); for (idx, row) in input.rows.iter().take(5).enumerate() { out.push_str(&format!( @@ -584,14 +481,6 @@ fn render_markdown(input: ReportInput<'_>) -> String { out } -fn percent_of(part: usize, total: usize) -> f64 { - if total == 0 { - 0.0 - } else { - (part as f64 / total as f64) * 100.0 - } -} - fn table_states_from_features(features: Vec) -> Result> { let mut grouped: BTreeMap = BTreeMap::new(); for feature in features { @@ -1244,16 +1133,12 @@ mod tests { assert!( report.contains("The workload generator emitted no events for this table's source.") ); - assert!(report.contains("## Sorted Op Table")); - assert!(report.contains("## Sorted Op Entity-Feature Details")); + assert!(!report.contains("## Sorted Op Table")); + assert!(!report.contains("## Sorted Op Entity-Feature Details")); assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); - assert!(report.contains("| Rank | Op | Shape |")); - assert!(report.contains( - "| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied |" - )); - assert!(report.contains("`txn_count_lifetime` | `user_id` | 1 |")); + assert!(report.contains("`txn_count_lifetime` | `count` | `lifetime` | 1 |")); assert!(report.contains("- Entity key:")); assert!(report.contains("- Entity events:")); assert!(report.contains("- Events applied: `1`")); diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs index d0a4a8f4..7eef4383 100644 --- a/crates/beava-bench/tests/memprofile_smoke.rs +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -37,19 +37,16 @@ fn memprofile_smoke_writes_required_sections() { assert!(report.contains("#### Largest Entity Rows")); assert!(report.contains("#### Feature Breakdown For Largest Entity")); assert!(report.contains("The workload generator emitted no events for this table's source.")); - assert!(report.contains("## Sorted Op Table")); - assert!(report.contains("## Sorted Op Entity-Feature Details")); + assert!(!report.contains("## Sorted Op Table")); + assert!(!report.contains("## Sorted Op Entity-Feature Details")); assert!(report.contains("## Top 5 Offenders")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); - assert!(report.contains("| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes |")); assert!(report.contains("enum_slot_bytes")); assert!(report.contains("payload_bytes")); assert!(report.contains("slack_bytes")); - assert!(report.contains( - "| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes |" - )); - assert!(report.contains("`txn_count_lifetime` | `user_id` | 1 | 80 | 80 | 8 | 72 | 0 | 80 |")); + assert!(report + .contains("`txn_count_lifetime` | `count` | `lifetime` | 1 | 80 | 80 | 8 | 72 | 0 | 80 |")); assert!(report.contains("- Path: `Txn` ->")); assert!(report.contains("- Entity key:")); assert!(report.contains("- Entity events:")); diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 8f2706a5..5dcd33bd 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -330,1583 +330,6 @@ No active entity rows. Configured features: `8`. The workload generator emitted No active entity rows. Configured features: `4`. The workload generator emitted no events for this table's source. -## Sorted Op Table - -| Rank | Op | Shape | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | -|------|----|-------|-------------|-----------------|---------------|-------------|------------|-------------| -| 1 | `quantile` | `windowed` | 544720 | 544720 | 54472 | 490248 | 16450544 | 16995264 | -| 2 | `n_unique` | `windowed` | 888720 | 888720 | 88872 | 799848 | 4710216 | 5598936 | -| 3 | `count` | `windowed` | 956480 | 956480 | 95648 | 860832 | 3060736 | 4017216 | -| 4 | `distance_from_home` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 3409040 | 3567600 | -| 5 | `reservoir_sample` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 3171200 | 3329760 | -| 6 | `burst_count` | `windowed` | 226880 | 226880 | 204192 | 22688 | 2904064 | 3130944 | -| 7 | `seasonal_deviation` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 2823558 | 2982118 | -| 8 | `dow_hour_histogram` | `lifetime` | 158560 | 158560 | 47568 | 110992 | 2663808 | 2822368 | -| 9 | `bloom_member` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 2536960 | 2695520 | -| 10 | `top_k` | `windowed` | 227520 | 227520 | 22752 | 204768 | 1567104 | 1794624 | -| 11 | `sum` | `windowed` | 227520 | 227520 | 22752 | 204768 | 728064 | 955584 | -| 12 | `entropy` | `windowed` | 158560 | 158560 | 15856 | 142704 | 786164 | 944724 | -| 13 | `mean` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | -| 14 | `min` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | -| 15 | `std` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | -| 16 | `var` | `windowed` | 158560 | 158560 | 15856 | 142704 | 507392 | 665952 | -| 17 | `hour_of_day_histogram` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 499464 | 658024 | -| 18 | `geo_spread` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 427321 | 585881 | -| 19 | `event_type_mix` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 413696 | 572256 | -| 20 | `geo_velocity` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 381469 | 540029 | -| 21 | `geo_distance` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 351735 | 510295 | -| 22 | `n_unique` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 332976 | 491536 | -| 23 | `last_n` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 317120 | 475680 | -| 24 | `most_recent_n` | `lifetime` | 158560 | 158560 | 95136 | 63424 | 317120 | 475680 | -| 25 | `first_seen` | `lifetime` | 433760 | 433760 | 173504 | 260256 | 0 | 433760 | -| 26 | `first_n` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 253696 | 412256 | -| 27 | `age` | `lifetime` | 364720 | 364720 | 145888 | 218832 | 0 | 364720 | -| 28 | `lag` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 126848 | 285408 | -| 29 | `entropy` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 110992 | 269552 | -| 30 | `time_since_last_n` | `lifetime` | 158560 | 158560 | 79280 | 79280 | 79280 | 237840 | -| 31 | `last_seen` | `lifetime` | 227440 | 227440 | 90976 | 136464 | 0 | 227440 | -| 32 | `negative_streak` | `lifetime` | 226880 | 226880 | 22688 | 204192 | 0 | 226880 | -| 33 | `count` | `lifetime` | 158560 | 158560 | 15856 | 142704 | 0 | 158560 | -| 34 | `decayed_count` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 35 | `decayed_sum` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 36 | `delta_from_prev` | `lifetime` | 158560 | 158560 | 47568 | 110992 | 0 | 158560 | -| 37 | `ew_zscore` | `lifetime` | 158560 | 158560 | 95136 | 63424 | 0 | 158560 | -| 38 | `ewma` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 39 | `ewvar` | `lifetime` | 158560 | 158560 | 95136 | 63424 | 0 | 158560 | -| 40 | `first` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 41 | `first_seen_in_window` | `windowed` | 158560 | 158560 | 47568 | 110992 | 0 | 158560 | -| 42 | `has_seen` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 43 | `inter_arrival_stats` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | -| 44 | `last` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 45 | `max` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 46 | `max_streak` | `lifetime` | 158560 | 158560 | 31712 | 126848 | 0 | 158560 | -| 47 | `outlier_count` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | -| 48 | `rate_of_change` | `windowed` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 49 | `streak` | `lifetime` | 158560 | 158560 | 31712 | 126848 | 0 | 158560 | -| 50 | `sum` | `lifetime` | 158560 | 158560 | 31712 | 126848 | 0 | 158560 | -| 51 | `time_since` | `lifetime` | 158560 | 158560 | 63424 | 95136 | 0 | 158560 | -| 52 | `trend` | `windowed` | 158560 | 158560 | 95136 | 63424 | 0 | 158560 | -| 53 | `trend_residual` | `windowed` | 158560 | 158560 | 142704 | 15856 | 0 | 158560 | -| 54 | `twa` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | -| 55 | `value_change_count` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | -| 56 | `z_score` | `windowed` | 158560 | 158560 | 79280 | 79280 | 0 | 158560 | - -## Sorted Op Entity-Feature Details - -Secondary diagnostic view: top entity-feature contributors under each op/shape parent. The table/entity sections above are the primary bytes-per-entity view. - -### 1. `quantile` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 1 | `Txn` | `TxnByMerchant` | `s470` | `merchant_amount_p99_24h` | `merchant_id` | 9 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s176` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s278` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s387` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s507` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s570` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s707` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s825` | `merchant_amount_p99_24h` | `merchant_id` | 7 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s12` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s172` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s201` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s365` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s371` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s39` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s498` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s537` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s591` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s643` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s655` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | -| 1 | `Txn` | `TxnByMerchant` | `s717` | `merchant_amount_p99_24h` | `merchant_id` | 6 | 80 | 80 | 8 | 72 | 2416 | 2496 | 0.0% | - -Showing top 20 of `6809` entity-feature rows for this op/shape. - -### 2. `n_unique` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 2 | `Txn` | `TxnByCard` | `s409` | `merchants_per_card_24h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s389` | `cards_per_ip_1h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s389` | `users_per_ip_24h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByMerchant` | `s470` | `users_per_merchant_24h` | `merchant_id` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s122` | `cards_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s122` | `users_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s466` | `cards_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s466` | `users_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByCard` | `s179` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByCard` | `s42` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByCard` | `s450` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByCard` | `s896` | `merchants_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByDevice` | `s377` | `cards_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByDevice` | `s377` | `users_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByDevice` | `s717` | `cards_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByDevice` | `s717` | `users_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByDevice` | `s743` | `cards_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByDevice` | `s743` | `users_per_device_24h` | `device_id` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s132` | `cards_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | -| 2 | `Txn` | `TxnByIp` | `s132` | `users_per_ip_24h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | 0.0% | - -Showing top 20 of `11109` entity-feature rows for this op/shape. - -### 3. `count` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 3 | `Txn` | `TxnByCard` | `s409` | `decline_count_1h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s409` | `txn_per_card_1h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s409` | `txn_per_card_24h` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByIp` | `s389` | `txn_per_ip_1h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByIp` | `s389` | `txn_per_ip_24h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByMerchant` | `s470` | `txn_per_merchant_24h` | `merchant_id` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByIp` | `s122` | `txn_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByIp` | `s122` | `txn_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByIp` | `s466` | `txn_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByIp` | `s466` | `txn_per_ip_24h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s179` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s179` | `txn_per_card_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s179` | `txn_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s42` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s42` | `txn_per_card_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s42` | `txn_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s450` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s450` | `txn_per_card_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s450` | `txn_per_card_24h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 3 | `Txn` | `TxnByCard` | `s896` | `decline_count_1h` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | - -Showing top 20 of `11956` entity-feature rows for this op/shape. - -### 4. `distance_from_home` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 4 | `Txn` | `TxnByUser` | `k00013835` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00017893` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00022821` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00029943` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00030706` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00030832` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00031894` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00039938` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00041244` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00041440` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00042338` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00046226` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00053345` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00055008` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00064964` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00067574` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00070333` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00089428` | `dist_from_home` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00000032` | `dist_from_home` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | -| 4 | `Txn` | `TxnByUser` | `k00000045` | `dist_from_home` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1720 | 1800 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 5. `reservoir_sample` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 5 | `Txn` | `TxnByUser` | `k00013835` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00017893` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00022821` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00029943` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00030706` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00030832` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00031894` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00039938` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00041244` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00041440` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00042338` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00046226` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00053345` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00055008` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00064964` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00067574` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00070333` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00089428` | `reservoir_50` | `user_id` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00000032` | `reservoir_50` | `user_id` | 1 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | -| 5 | `Txn` | `TxnByUser` | `k00000045` | `reservoir_50` | `user_id` | 1 | 80 | 80 | 40 | 40 | 1600 | 1680 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 6. `burst_count` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 6 | `Txn` | `TxnByCard` | `s409` | `small_amt_burst_5m` | `card_fp` | 10 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s179` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s42` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s450` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s896` | `small_amt_burst_5m` | `card_fp` | 7 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s138` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s274` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s337` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s354` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s433` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s474` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s555` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s560` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s566` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s654` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s770` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s957` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s996` | `small_amt_burst_5m` | `card_fp` | 6 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s129` | `small_amt_burst_5m` | `card_fp` | 5 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | -| 6 | `Txn` | `TxnByCard` | `s150` | `small_amt_burst_5m` | `card_fp` | 5 | 80 | 80 | 72 | 8 | 1024 | 1104 | 0.0% | - -Showing top 20 of `2836` entity-feature rows for this op/shape. - -### 7. `seasonal_deviation` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 7 | `Txn` | `TxnByUser` | `k00000181` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00000870` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00001150` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00001671` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00001874` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00001952` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00002108` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00002920` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00003254` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00003623` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00004116` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00004151` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00004200` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00004653` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00005051` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00005603` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00006199` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00006234` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00006914` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | -| 7 | `Txn` | `TxnByUser` | `k00007171` | `seasonal_dev` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1427 | 1507 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 8. `dow_hour_histogram` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 8 | `Txn` | `TxnByUser` | `k00013835` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00017893` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00022821` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00029943` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00030706` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00030832` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00031894` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00039938` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00041244` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00041440` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00042338` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00046226` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00053345` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00055008` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00064964` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00067574` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00070333` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00089428` | `dow_hour_hist_30d` | `user_id` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00000032` | `dow_hour_hist_30d` | `user_id` | 1 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | -| 8 | `Txn` | `TxnByUser` | `k00000045` | `dow_hour_hist_30d` | `user_id` | 1 | 80 | 80 | 24 | 56 | 1344 | 1424 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 9. `bloom_member` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 9 | `Txn` | `TxnByUser` | `k00013835` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00017893` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00022821` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00029943` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00030706` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00030832` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00031894` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00039938` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00041244` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00041440` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00042338` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00046226` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00053345` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00055008` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00064964` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00067574` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00070333` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00089428` | `device_seen` | `user_id` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00000032` | `device_seen` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 9 | `Txn` | `TxnByUser` | `k00000045` | `device_seen` | `user_id` | 1 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 10. `top_k` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 10 | `Txn` | `TxnByIp` | `s389` | `ip_top_users` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 1280 | 1360 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s122` | `ip_top_users` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 1184 | 1264 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s466` | `ip_top_users` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 1184 | 1264 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s132` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s226` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s683` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s789` | `ip_top_users` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 1088 | 1168 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s108` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s140` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s161` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s225` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s227` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s279` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s486` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s629` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s681` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s69` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s780` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s825` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | -| 10 | `Txn` | `TxnByIp` | `s928` | `ip_top_users` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 992 | 1072 | 0.1% | - -Showing top 20 of `2844` entity-feature rows for this op/shape. - -### 11. `sum` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 11 | `Txn` | `TxnByIp` | `s389` | `amount_sum_per_ip_1h` | `ip_address` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s122` | `amount_sum_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s466` | `amount_sum_per_ip_1h` | `ip_address` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s132` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s226` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s683` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s789` | `amount_sum_per_ip_1h` | `ip_address` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s108` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s140` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s161` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s225` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s227` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s279` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s486` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s629` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s681` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s69` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s780` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s825` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | -| 11 | `Txn` | `TxnByIp` | `s928` | `amount_sum_per_ip_1h` | `ip_address` | 6 | 80 | 80 | 8 | 72 | 256 | 336 | 0.0% | - -Showing top 20 of `2844` entity-feature rows for this op/shape. - -### 12. `entropy` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 12 | `Txn` | `TxnByUser` | `k00013835` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00017893` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00022821` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00029943` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00030706` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00030832` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00031894` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00041244` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00042338` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00046226` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00053345` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00055008` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00064964` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00067574` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00070333` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00089428` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00039938` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 479 | 559 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00041440` | `mcc_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 479 | 559 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00000032` | `mcc_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 396 | 476 | 0.1% | -| 12 | `Txn` | `TxnByUser` | `k00000045` | `mcc_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 396 | 476 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 13. `mean` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 13 | `Txn` | `TxnByUser` | `k00013835` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00017893` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00022821` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00029943` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00030706` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00030832` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00031894` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00039938` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00041244` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00041440` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00042338` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00046226` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00053345` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00055008` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00064964` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00067574` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00070333` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00089428` | `avg_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00000032` | `avg_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 13 | `Txn` | `TxnByUser` | `k00000045` | `avg_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 14. `min` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 14 | `Txn` | `TxnByUser` | `k00013835` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00017893` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00022821` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00029943` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00030706` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00030832` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00031894` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00039938` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00041244` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00041440` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00042338` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00046226` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00053345` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00055008` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00064964` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00067574` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00070333` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00089428` | `min_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00000032` | `min_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 14 | `Txn` | `TxnByUser` | `k00000045` | `min_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 15. `std` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 15 | `Txn` | `TxnByUser` | `k00013835` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00017893` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00022821` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00029943` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00030706` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00030832` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00031894` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00039938` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00041244` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00041440` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00042338` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00046226` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00053345` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00055008` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00064964` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00067574` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00070333` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00089428` | `std_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00000032` | `std_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 15 | `Txn` | `TxnByUser` | `k00000045` | `std_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 16. `var` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 16 | `Txn` | `TxnByUser` | `k00013835` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00017893` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00022821` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00029943` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00030706` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00030832` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00031894` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00039938` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00041244` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00041440` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00042338` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00046226` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00053345` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00055008` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00064964` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00067574` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00070333` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00089428` | `var_amount_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00000032` | `var_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | -| 16 | `Txn` | `TxnByUser` | `k00000045` | `var_amount_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 256 | 336 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 17. `hour_of_day_histogram` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 17 | `Txn` | `TxnByUser` | `k00013835` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00017893` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00022821` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00029943` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00030706` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00030832` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00031894` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00039938` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00041244` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00041440` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00042338` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00046226` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00053345` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00055008` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00064964` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00067574` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00070333` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00089428` | `hour_hist_30d` | `user_id` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00000032` | `hour_hist_30d` | `user_id` | 1 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | -| 17 | `Txn` | `TxnByUser` | `k00000045` | `hour_hist_30d` | `user_id` | 1 | 80 | 80 | 8 | 72 | 252 | 332 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 18. `geo_spread` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 18 | `Txn` | `TxnByUser` | `k00029943` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 246 | 326 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00013835` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00022821` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00041244` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00041440` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00042338` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00046226` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00055008` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00070333` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 245 | 325 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00017893` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00030706` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00031894` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00039938` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00064964` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00067574` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00089428` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 244 | 324 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00030832` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 243 | 323 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00053345` | `geo_spread_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 243 | 323 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00000113` | `geo_spread_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 217 | 297 | 0.1% | -| 18 | `Txn` | `TxnByUser` | `k00001471` | `geo_spread_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 217 | 297 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 19. `event_type_mix` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 19 | `Txn` | `TxnByUser` | `k00013835` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00017893` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00022821` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00029943` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00030706` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00030832` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00031894` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00039938` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00041244` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00041440` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00042338` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00046226` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00053345` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00055008` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00064964` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00067574` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00070333` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00089428` | `event_mix_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00000032` | `event_mix_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | -| 19 | `Txn` | `TxnByUser` | `k00000045` | `event_mix_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 20. `geo_velocity` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 20 | `Txn` | `TxnByUser` | `k00055008` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 209 | 289 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00029943` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00067574` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00070333` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00017893` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00022821` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00030706` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00039938` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00053345` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 207 | 287 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00013835` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00030832` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00031894` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00041440` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00042338` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00046226` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00064964` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00089428` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 206 | 286 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00041244` | `geo_kmh` | `user_id` | 2 | 80 | 80 | 8 | 72 | 204 | 284 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00000113` | `geo_kmh` | `user_id` | 1 | 80 | 80 | 8 | 72 | 194 | 274 | 0.1% | -| 20 | `Txn` | `TxnByUser` | `k00001471` | `geo_kmh` | `user_id` | 1 | 80 | 80 | 8 | 72 | 194 | 274 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 21. `geo_distance` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 21 | `Txn` | `TxnByUser` | `k00029943` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00055008` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00067574` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00070333` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00030706` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 192 | 272 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00046226` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 192 | 272 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00053345` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 192 | 272 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00013835` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00017893` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00022821` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00031894` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00039938` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00041440` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00042338` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00064964` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00089428` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 191 | 271 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00030832` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 190 | 270 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00041244` | `geo_dist_last` | `user_id` | 2 | 80 | 80 | 8 | 72 | 189 | 269 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00000113` | `geo_dist_last` | `user_id` | 1 | 80 | 80 | 8 | 72 | 179 | 259 | 0.1% | -| 21 | `Txn` | `TxnByUser` | `k00001471` | `geo_dist_last` | `user_id` | 1 | 80 | 80 | 8 | 72 | 179 | 259 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 22. `n_unique` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 22 | `Txn` | `TxnByUser` | `k00013835` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00017893` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00022821` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00029943` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00030706` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00030832` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00031894` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00039938` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00041244` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00041440` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00042338` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00046226` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00053345` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00055008` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00064964` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00067574` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00070333` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00089428` | `unique_cells_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00000032` | `unique_cells_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | -| 22 | `Txn` | `TxnByUser` | `k00000045` | `unique_cells_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 168 | 248 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 23. `last_n` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 23 | `Txn` | `TxnByUser` | `k00013835` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00017893` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00022821` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00029943` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00030706` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00030832` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00031894` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00039938` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00041244` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00041440` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00042338` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00046226` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00053345` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00055008` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00064964` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00067574` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00070333` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00089428` | `last_5_amounts` | `user_id` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00000032` | `last_5_amounts` | `user_id` | 1 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | -| 23 | `Txn` | `TxnByUser` | `k00000045` | `last_5_amounts` | `user_id` | 1 | 80 | 80 | 40 | 40 | 160 | 240 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 24. `most_recent_n` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 24 | `Txn` | `TxnByUser` | `k00013835` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00017893` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00022821` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00029943` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00030706` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00030832` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00031894` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00039938` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00041244` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00041440` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00042338` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00046226` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00053345` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00055008` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00064964` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00067574` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00070333` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00089428` | `recent_5_amts` | `user_id` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00000032` | `recent_5_amts` | `user_id` | 1 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | -| 24 | `Txn` | `TxnByUser` | `k00000045` | `recent_5_amts` | `user_id` | 1 | 80 | 80 | 48 | 32 | 160 | 240 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 25. `first_seen` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 25 | `Txn` | `TxnByCard` | `s409` | `card_first_seen` | `card_fp` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s389` | `ip_first_seen` | `ip_address` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByMerchant` | `s470` | `merchant_first_seen` | `merchant_id` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s122` | `ip_first_seen` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s466` | `ip_first_seen` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByCard` | `s179` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByCard` | `s42` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByCard` | `s450` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByCard` | `s896` | `card_first_seen` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByDevice` | `s377` | `device_first_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByDevice` | `s717` | `device_first_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByDevice` | `s743` | `device_first_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s132` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s226` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s683` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByIp` | `s789` | `ip_first_seen` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByMerchant` | `s176` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByMerchant` | `s278` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByMerchant` | `s387` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 25 | `Txn` | `TxnByMerchant` | `s507` | `merchant_first_seen` | `merchant_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | - -Showing top 20 of `5422` entity-feature rows for this op/shape. - -### 26. `first_n` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 26 | `Txn` | `TxnByUser` | `k00013835` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00017893` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00022821` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00029943` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00030706` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00030832` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00031894` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00039938` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00041244` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00041440` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00042338` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00046226` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00053345` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00055008` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00064964` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00067574` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00070333` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00089428` | `first_5_merchants` | `user_id` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00000032` | `first_5_merchants` | `user_id` | 1 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | -| 26 | `Txn` | `TxnByUser` | `k00000045` | `first_5_merchants` | `user_id` | 1 | 80 | 80 | 32 | 48 | 128 | 208 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 27. `age` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 27 | `Txn` | `TxnByCard` | `s409` | `card_age` | `card_fp` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s389` | `ip_age` | `ip_address` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s122` | `ip_age` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s466` | `ip_age` | `ip_address` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s179` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s42` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s450` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s896` | `card_age` | `card_fp` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByDevice` | `s377` | `device_age` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByDevice` | `s717` | `device_age` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByDevice` | `s743` | `device_age` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s132` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s226` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s683` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByIp` | `s789` | `ip_age` | `ip_address` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s138` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s274` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s337` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s354` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 27 | `Txn` | `TxnByCard` | `s433` | `card_age` | `card_fp` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | - -Showing top 20 of `4559` entity-feature rows for this op/shape. - -### 28. `lag` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 28 | `Txn` | `TxnByUser` | `k00013835` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00017893` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00022821` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00029943` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00030706` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00030832` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00031894` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00039938` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00041244` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00041440` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00042338` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00046226` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00053345` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00055008` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00064964` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00067574` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00070333` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00089428` | `amount_lag1` | `user_id` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00000032` | `amount_lag1` | `user_id` | 1 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | -| 28 | `Txn` | `TxnByUser` | `k00000045` | `amount_lag1` | `user_id` | 1 | 80 | 80 | 40 | 40 | 64 | 144 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 29. `entropy` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 29 | `Txn` | `TxnByUser` | `k00013835` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00017893` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00022821` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00029943` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00030706` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00030832` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00031894` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00039938` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00041244` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00041440` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00042338` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00046226` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00053345` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00055008` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00064964` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00067574` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00070333` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00089428` | `geo_entropy_24h` | `user_id` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00000032` | `geo_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | -| 29 | `Txn` | `TxnByUser` | `k00000045` | `geo_entropy_24h` | `user_id` | 1 | 80 | 80 | 8 | 72 | 56 | 136 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 30. `time_since_last_n` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 30 | `Txn` | `TxnByUser` | `k00013835` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00017893` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00022821` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00029943` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00030706` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00030832` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00031894` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00039938` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00041244` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00041440` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00042338` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00046226` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00053345` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00055008` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00064964` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00067574` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00070333` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00089428` | `time_since_last_5` | `user_id` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00000032` | `time_since_last_5` | `user_id` | 1 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | -| 30 | `Txn` | `TxnByUser` | `k00000045` | `time_since_last_5` | `user_id` | 1 | 80 | 80 | 40 | 40 | 40 | 120 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 31. `last_seen` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 31 | `Txn` | `TxnByDevice` | `s377` | `device_last_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s717` | `device_last_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s743` | `device_last_seen` | `device_id` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s107` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s171` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s469` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s519` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s586` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s632` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s66` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s846` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s903` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s955` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s959` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s960` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s994` | `device_last_seen` | `device_id` | 6 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s116` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s118` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s136` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | -| 31 | `Txn` | `TxnByDevice` | `s177` | `device_last_seen` | `device_id` | 5 | 80 | 80 | 32 | 48 | 0 | 80 | 0.0% | - -Showing top 20 of `2843` entity-feature rows for this op/shape. - -### 32. `negative_streak` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 32 | `Txn` | `TxnByCard` | `s409` | `decline_streak_card` | `card_fp` | 10 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s179` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s42` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s450` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s896` | `decline_streak_card` | `card_fp` | 7 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s138` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s274` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s337` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s354` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s433` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s474` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s555` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s560` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s566` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s654` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s770` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s957` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s996` | `decline_streak_card` | `card_fp` | 6 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s129` | `decline_streak_card` | `card_fp` | 5 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | -| 32 | `Txn` | `TxnByCard` | `s150` | `decline_streak_card` | `card_fp` | 5 | 80 | 80 | 8 | 72 | 0 | 80 | 0.0% | - -Showing top 20 of `2836` entity-feature rows for this op/shape. - -### 33. `count` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 33 | `Txn` | `TxnByUser` | `k00013835` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00017893` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00022821` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00029943` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00030706` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00030832` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00031894` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00039938` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00041244` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00041440` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00042338` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00046226` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00053345` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00055008` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00064964` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00067574` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00070333` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00089428` | `txn_count_lifetime` | `user_id` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00000032` | `txn_count_lifetime` | `user_id` | 1 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | -| 33 | `Txn` | `TxnByUser` | `k00000045` | `txn_count_lifetime` | `user_id` | 1 | 80 | 80 | 8 | 72 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 34. `decayed_count` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 34 | `Txn` | `TxnByUser` | `k00013835` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00017893` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00022821` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00029943` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00030706` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00030832` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00031894` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00039938` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00041244` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00041440` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00042338` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00046226` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00053345` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00055008` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00064964` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00067574` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00070333` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00089428` | `txn_decayed_count_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00000032` | `txn_decayed_count_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 34 | `Txn` | `TxnByUser` | `k00000045` | `txn_decayed_count_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 35. `decayed_sum` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 35 | `Txn` | `TxnByUser` | `k00013835` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00017893` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00022821` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00029943` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00030706` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00030832` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00031894` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00039938` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00041244` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00041440` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00042338` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00046226` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00053345` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00055008` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00064964` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00067574` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00070333` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00089428` | `amount_decayed_sum_24h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00000032` | `amount_decayed_sum_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 35 | `Txn` | `TxnByUser` | `k00000045` | `amount_decayed_sum_24h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 36. `delta_from_prev` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 36 | `Txn` | `TxnByUser` | `k00013835` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00017893` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00022821` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00029943` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00030706` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00030832` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00031894` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00039938` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00041244` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00041440` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00042338` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00046226` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00053345` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00055008` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00064964` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00067574` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00070333` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00089428` | `amount_delta` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00000032` | `amount_delta` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 36 | `Txn` | `TxnByUser` | `k00000045` | `amount_delta` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 37. `ew_zscore` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 37 | `Txn` | `TxnByUser` | `k00013835` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00017893` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00022821` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00029943` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00030706` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00030832` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00031894` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00039938` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00041244` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00041440` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00042338` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00046226` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00053345` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00055008` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00064964` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00067574` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00070333` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00089428` | `amount_ew_zscore` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00000032` | `amount_ew_zscore` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 37 | `Txn` | `TxnByUser` | `k00000045` | `amount_ew_zscore` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 38. `ewma` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 38 | `Txn` | `TxnByUser` | `k00013835` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00017893` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00022821` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00029943` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00030706` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00030832` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00031894` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00039938` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00041244` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00041440` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00042338` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00046226` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00053345` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00055008` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00064964` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00067574` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00070333` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00089428` | `amount_ewma_1h` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00000032` | `amount_ewma_1h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 38 | `Txn` | `TxnByUser` | `k00000045` | `amount_ewma_1h` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 39. `ewvar` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 39 | `Txn` | `TxnByUser` | `k00013835` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00017893` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00022821` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00029943` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00030706` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00030832` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00031894` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00039938` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00041244` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00041440` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00042338` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00046226` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00053345` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00055008` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00064964` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00067574` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00070333` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00089428` | `amount_ewvar_1h` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00000032` | `amount_ewvar_1h` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 39 | `Txn` | `TxnByUser` | `k00000045` | `amount_ewvar_1h` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 40. `first` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 40 | `Txn` | `TxnByUser` | `k00013835` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00017893` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00022821` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00029943` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00030706` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00030832` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00031894` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00039938` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00041244` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00041440` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00042338` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00046226` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00053345` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00055008` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00064964` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00067574` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00070333` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00089428` | `first_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00000032` | `first_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 40 | `Txn` | `TxnByUser` | `k00000045` | `first_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 41. `first_seen_in_window` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 41 | `Txn` | `TxnByUser` | `k00013835` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00017893` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00022821` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00029943` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00030706` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00030832` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00031894` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00039938` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00041244` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00041440` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00042338` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00046226` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00053345` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00055008` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00064964` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00067574` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00070333` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00089428` | `first_in_24h` | `user_id` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00000032` | `first_in_24h` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | -| 41 | `Txn` | `TxnByUser` | `k00000045` | `first_in_24h` | `user_id` | 1 | 80 | 80 | 24 | 56 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 42. `has_seen` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 42 | `Txn` | `TxnByUser` | `k00013835` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00017893` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00022821` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00029943` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00030706` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00030832` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00031894` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00039938` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00041244` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00041440` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00042338` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00046226` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00053345` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00055008` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00064964` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00067574` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00070333` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00089428` | `has_seen` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00000032` | `has_seen` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 42 | `Txn` | `TxnByUser` | `k00000045` | `has_seen` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 43. `inter_arrival_stats` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 43 | `Txn` | `TxnByUser` | `k00013835` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00017893` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00022821` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00029943` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00030706` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00030832` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00031894` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00039938` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00041244` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00041440` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00042338` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00046226` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00053345` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00055008` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00064964` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00067574` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00070333` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00089428` | `inter_arrival_1h` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00000032` | `inter_arrival_1h` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 43 | `Txn` | `TxnByUser` | `k00000045` | `inter_arrival_1h` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 44. `last` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 44 | `Txn` | `TxnByUser` | `k00013835` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00017893` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00022821` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00029943` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00030706` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00030832` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00031894` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00039938` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00041244` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00041440` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00042338` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00046226` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00053345` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00055008` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00064964` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00067574` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00070333` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00089428` | `last_amount` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00000032` | `last_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 44 | `Txn` | `TxnByUser` | `k00000045` | `last_amount` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 45. `max` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 45 | `Txn` | `TxnByUser` | `k00013835` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00017893` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00022821` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00029943` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00030706` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00030832` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00031894` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00039938` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00041244` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00041440` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00042338` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00046226` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00053345` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00055008` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00064964` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00067574` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00070333` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00089428` | `max_amount_lifetime` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00000032` | `max_amount_lifetime` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 45 | `Txn` | `TxnByUser` | `k00000045` | `max_amount_lifetime` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 46. `max_streak` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 46 | `Txn` | `TxnByUser` | `k00013835` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00017893` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00022821` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00029943` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00030706` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00030832` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00031894` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00039938` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00041244` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00041440` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00042338` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00046226` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00053345` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00055008` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00064964` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00067574` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00070333` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00089428` | `max_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00000032` | `max_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 46 | `Txn` | `TxnByUser` | `k00000045` | `max_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 47. `outlier_count` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 47 | `Txn` | `TxnByUser` | `k00013835` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00017893` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00022821` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00029943` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00030706` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00030832` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00031894` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00039938` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00041244` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00041440` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00042338` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00046226` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00053345` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00055008` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00064964` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00067574` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00070333` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00089428` | `amount_outliers_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00000032` | `amount_outliers_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 47 | `Txn` | `TxnByUser` | `k00000045` | `amount_outliers_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 48. `rate_of_change` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 48 | `Txn` | `TxnByUser` | `k00013835` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00017893` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00022821` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00029943` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00030706` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00030832` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00031894` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00039938` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00041244` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00041440` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00042338` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00046226` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00053345` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00055008` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00064964` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00067574` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00070333` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00089428` | `amount_rate_5m` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00000032` | `amount_rate_5m` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 48 | `Txn` | `TxnByUser` | `k00000045` | `amount_rate_5m` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 49. `streak` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 49 | `Txn` | `TxnByUser` | `k00013835` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00017893` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00022821` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00029943` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00030706` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00030832` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00031894` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00039938` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00041244` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00041440` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00042338` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00046226` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00053345` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00055008` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00064964` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00067574` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00070333` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00089428` | `txn_streak` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00000032` | `txn_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 49 | `Txn` | `TxnByUser` | `k00000045` | `txn_streak` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 50. `sum` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 50 | `Txn` | `TxnByUser` | `k00013835` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00017893` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00022821` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00029943` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00030706` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00030832` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00031894` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00039938` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00041244` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00041440` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00042338` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00046226` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00053345` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00055008` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00064964` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00067574` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00070333` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00089428` | `sum_amount_lifetime` | `user_id` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00000032` | `sum_amount_lifetime` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | -| 50 | `Txn` | `TxnByUser` | `k00000045` | `sum_amount_lifetime` | `user_id` | 1 | 80 | 80 | 16 | 64 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 51. `time_since` / `lifetime` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 51 | `Txn` | `TxnByUser` | `k00013835` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00017893` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00022821` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00029943` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00030706` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00030832` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00031894` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00039938` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00041244` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00041440` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00042338` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00046226` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00053345` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00055008` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00064964` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00067574` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00070333` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00089428` | `time_since_last` | `user_id` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00000032` | `time_since_last` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | -| 51 | `Txn` | `TxnByUser` | `k00000045` | `time_since_last` | `user_id` | 1 | 80 | 80 | 32 | 48 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 52. `trend` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 52 | `Txn` | `TxnByUser` | `k00013835` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00017893` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00022821` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00029943` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00030706` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00030832` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00031894` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00039938` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00041244` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00041440` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00042338` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00046226` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00053345` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00055008` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00064964` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00067574` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00070333` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00089428` | `amount_trend_5m` | `user_id` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00000032` | `amount_trend_5m` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | -| 52 | `Txn` | `TxnByUser` | `k00000045` | `amount_trend_5m` | `user_id` | 1 | 80 | 80 | 48 | 32 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 53. `trend_residual` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 53 | `Txn` | `TxnByUser` | `k00013835` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00017893` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00022821` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00029943` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00030706` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00030832` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00031894` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00039938` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00041244` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00041440` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00042338` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00046226` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00053345` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00055008` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00064964` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00067574` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00070333` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00089428` | `amount_trend_resid_5m` | `user_id` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00000032` | `amount_trend_resid_5m` | `user_id` | 1 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | -| 53 | `Txn` | `TxnByUser` | `k00000045` | `amount_trend_resid_5m` | `user_id` | 1 | 80 | 80 | 72 | 8 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 54. `twa` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 54 | `Txn` | `TxnByUser` | `k00013835` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00017893` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00022821` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00029943` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00030706` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00030832` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00031894` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00039938` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00041244` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00041440` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00042338` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00046226` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00053345` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00055008` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00064964` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00067574` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00070333` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00089428` | `amount_twa_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00000032` | `amount_twa_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 54 | `Txn` | `TxnByUser` | `k00000045` | `amount_twa_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 55. `value_change_count` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 55 | `Txn` | `TxnByUser` | `k00013835` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00017893` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00022821` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00029943` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00030706` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00030832` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00031894` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00039938` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00041244` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00041440` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00042338` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00046226` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00053345` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00055008` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00064964` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00067574` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00070333` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00089428` | `device_change_count_5m` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00000032` | `device_change_count_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 55 | `Txn` | `TxnByUser` | `k00000045` | `device_change_count_5m` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - -### 56. `z_score` / `windowed` entity-feature rows - -| Parent rank | Source event | Derivation | Entity key | Feature | Key path | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | Parent % | -|-------------|--------------|------------|------------|---------|----------|----------------|-------------|-----------------|---------------|-------------|------------|-------------|----------| -| 56 | `Txn` | `TxnByUser` | `k00013835` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00017893` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00022821` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00029943` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00030706` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00030832` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00031894` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00039938` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00041244` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00041440` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00042338` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00046226` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00053345` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00055008` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00064964` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00067574` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00070333` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00089428` | `amount_z_score` | `user_id` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00000032` | `amount_z_score` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | -| 56 | `Txn` | `TxnByUser` | `k00000045` | `amount_z_score` | `user_id` | 1 | 80 | 80 | 40 | 40 | 0 | 80 | 0.1% | - -Showing top 20 of `1982` entity-feature rows for this op/shape. - ## Top 5 Offenders ### 1. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` From 2f0f20a6fdf86260e0cdb5e3f064d4d81f4f1fe8 Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Sun, 24 May 2026 15:35:00 -0400 Subject: [PATCH 7/9] Exact accounting instead of serialized size estimate for some AggOp --- crates/beava-bench/src/bin/memprofile.rs | 54 +- crates/beava-bench/tests/memprofile_smoke.rs | 2 + crates/beava-core/src/mem_usage.rs | 109 +++- memory-profile-fraud-team.md | 552 +++++++++---------- 4 files changed, 376 insertions(+), 341 deletions(-) diff --git a/crates/beava-bench/src/bin/memprofile.rs b/crates/beava-bench/src/bin/memprofile.rs index 10ab72c6..cf7b243f 100644 --- a/crates/beava-bench/src/bin/memprofile.rs +++ b/crates/beava-bench/src/bin/memprofile.rs @@ -6,7 +6,7 @@ use beava_core::mem_usage::{MemBreakdown, MemProfile, MemUsage}; use beava_core::row::{json_value_to_beava_value, Row, Value}; use clap::Parser; use serde_json::Value as JsonValue; -use std::collections::BTreeMap; +use std::collections::{BTreeMap, BTreeSet}; use std::fs; use std::path::PathBuf; @@ -48,7 +48,6 @@ struct ProfileRow { shape: ProfileShape, window_ms: Option, profile: MemProfile, - recommendation: String, } #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -386,7 +385,8 @@ fn render_markdown(input: ReportInput<'_>) -> String { } out.push_str("## Top 5 Offenders\n\n"); - for (idx, row) in input.rows.iter().take(5).enumerate() { + out.push_str("One heaviest entity-feature example per unique op.\n\n"); + for (idx, row) in top_unique_op_rows(input.rows, 5).iter().enumerate() { out.push_str(&format!( "### {}. `{}` / `{}` / `{}` / `{}`\n\n", idx + 1, @@ -424,7 +424,6 @@ fn render_markdown(input: ReportInput<'_>) -> String { row.shape.as_str(), format_window_suffix(row.window_ms) )); - out.push_str(&format!("- Recommendation: {}\n", row.recommendation)); if row.shape == ProfileShape::Windowed { out.push_str("- Breakdown rollup:\n"); for entry in windowed_rollup(&row.profile.breakdown) { @@ -477,7 +476,7 @@ fn render_markdown(input: ReportInput<'_>) -> String { out.push_str("- `payload_bytes` is the active variant payload inside the enum slot. For boxed variants this is the inline `Box` pointer, while the boxed pointee remains in `heap_bytes`.\n"); out.push_str("- `slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot: `enum_slot_bytes - payload_bytes`.\n"); out.push_str("- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate.\n"); - out.push_str("- Primary grain is `derivation table -> entity row -> feature column`; op/shape rows remain as secondary diagnostics for implementation-level hotspots.\n"); + out.push_str("- Primary grain is `derivation table -> entity row -> feature column`; top offenders list one concrete entity-feature row per unique op.\n"); out } @@ -534,7 +533,6 @@ fn collect_table_profiles(tables: Vec) -> (Vec, Vec) -> (Vec, Vec std::cmp::Ordering { .then_with(|| a.op_name.cmp(&b.op_name)) } +fn top_unique_op_rows(rows: &[ProfileRow], limit: usize) -> Vec<&ProfileRow> { + let mut seen = BTreeSet::new(); + let mut out = Vec::new(); + for row in rows { + if seen.insert(row.op_name.as_str()) { + out.push(row); + if out.len() == limit { + break; + } + } + } + out +} + fn windowed_rollup(entries: &[MemBreakdown]) -> Vec { let mut grouped: BTreeMap = BTreeMap::new(); for entry in entries { @@ -806,33 +817,6 @@ fn windowed_rollup_bucket(entry: &MemBreakdown) -> Option<(String, String, Strin )) } -fn recommendation_for(op_name: &str, shape: ProfileShape, profile: &MemProfile) -> String { - match (op_name, shape) { - ("n_unique", ProfileShape::Windowed) => { - "keep for now; quantify sketch precision and window bucket fanout separately" - .to_string() - } - ("count" | "sum" | "mean", ProfileShape::Windowed) => { - "keep scalar core; quantify whether wrapper and bucket fanout are the real cost" - .to_string() - } - ( - "quantile" | "n_unique" | "top_k" | "bloom_member" | "entropy", - ProfileShape::Lifetime, - ) => "keep for now; quantify sparse-to-dense sketch options next".to_string(), - ("burst_count" | "trend_residual", _) if profile.stack_bytes >= 80 => { - "box smaller if the report confirms broad per-entity prevalence".to_string() - } - ("count" | "sum" | "mean", _) if profile.heap_bytes == 0 => { - "keep; scalar state spends only the shared AggOp slot".to_string() - } - (_, ProfileShape::Windowed) => { - "restructure only if lazy bucket materialization still dominates".to_string() - } - _ => "keep; no targeted restructuring until workload ranking justifies it".to_string(), - } -} - fn profile_shape(desc: &AggOpDescriptor) -> ProfileShape { if desc.window_ms.is_some() { ProfileShape::Windowed @@ -1136,6 +1120,8 @@ mod tests { assert!(!report.contains("## Sorted Op Table")); assert!(!report.contains("## Sorted Op Entity-Feature Details")); assert!(report.contains("## Top 5 Offenders")); + assert!(report.contains("One heaviest entity-feature example per unique op.")); + assert!(!report.contains("- Recommendation:")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); assert!(report.contains("`txn_count_lifetime` | `count` | `lifetime` | 1 |")); diff --git a/crates/beava-bench/tests/memprofile_smoke.rs b/crates/beava-bench/tests/memprofile_smoke.rs index 7eef4383..29f1cda5 100644 --- a/crates/beava-bench/tests/memprofile_smoke.rs +++ b/crates/beava-bench/tests/memprofile_smoke.rs @@ -40,6 +40,8 @@ fn memprofile_smoke_writes_required_sections() { assert!(!report.contains("## Sorted Op Table")); assert!(!report.contains("## Sorted Op Entity-Feature Details")); assert!(report.contains("## Top 5 Offenders")); + assert!(report.contains("One heaviest entity-feature example per unique op.")); + assert!(!report.contains("- Recommendation:")); assert!(report.contains("## Metrics Coherence")); assert!(report.contains("Aggregate features discovered: `111`")); assert!(report.contains("enum_slot_bytes")); diff --git a/crates/beava-core/src/mem_usage.rs b/crates/beava-core/src/mem_usage.rs index 66c4a62b..da9f23cc 100644 --- a/crates/beava-core/src/mem_usage.rs +++ b/crates/beava-core/src/mem_usage.rs @@ -173,6 +173,15 @@ fn add_box_allocation( profile.add_breakdown(label, bytes, "Box", note); } +fn add_string_breakdown(profile: &mut MemProfile, label: impl Into, value: &String) { + profile.add_breakdown( + label, + value.capacity(), + "String", + "capacity bytes for owned string buffer", + ); +} + fn add_count_distinct_breakdown(profile: &mut MemProfile, state: &CountDistinctStateWrap) { add_box_allocation( profile, @@ -430,15 +439,48 @@ impl MemUsage for AggOp { ); } } - AggOp::HourOfDayHistogram(s) => { - add_boxed_serialized(&mut profile, "HourOfDayHistogram", &**s) + AggOp::HourOfDayHistogram(s) => add_box_allocation( + &mut profile, + "Box", + size_of_val(&**s), + "heap allocation for fixed inline hour-of-day counts", + ), + AggOp::SeasonalDeviation(s) => add_box_allocation( + &mut profile, + "Box", + size_of_val(&**s), + "heap allocation for fixed inline per-hour buckets", + ), + AggOp::GeoVelocity(s) => { + add_box_allocation( + &mut profile, + "Box", + size_of_val(&**s), + "heap allocation for boxed payload", + ); + add_string_breakdown(&mut profile, "GeoVelocity lat_field", &s.lat_field); + add_string_breakdown(&mut profile, "GeoVelocity lon_field", &s.lon_field); + } + AggOp::GeoDistance(s) => { + add_box_allocation( + &mut profile, + "Box", + size_of_val(&**s), + "heap allocation for boxed payload", + ); + add_string_breakdown(&mut profile, "GeoDistance lat_field", &s.lat_field); + add_string_breakdown(&mut profile, "GeoDistance lon_field", &s.lon_field); } - AggOp::SeasonalDeviation(s) => { - add_boxed_serialized(&mut profile, "SeasonalDeviation", &**s) + AggOp::GeoSpread(s) => { + add_box_allocation( + &mut profile, + "Box", + size_of_val(&**s), + "heap allocation for boxed payload", + ); + add_string_breakdown(&mut profile, "GeoSpread lat_field", &s.lat_field); + add_string_breakdown(&mut profile, "GeoSpread lon_field", &s.lon_field); } - AggOp::GeoVelocity(s) => add_boxed_serialized(&mut profile, "GeoVelocity", &**s), - AggOp::GeoDistance(s) => add_boxed_serialized(&mut profile, "GeoDistance", &**s), - AggOp::GeoSpread(s) => add_boxed_serialized(&mut profile, "GeoSpread", &**s), AggOp::DistanceFromHome(s) => { profile.add_breakdown( "Box", @@ -560,21 +602,6 @@ fn aggop_payload_bytes(op: &AggOp) -> usize { } } -fn add_boxed_serialized(profile: &mut MemProfile, label: &str, value: &T) { - profile.add_breakdown( - format!("Box<{label}>"), - size_of_val(value), - "Box", - "heap allocation for boxed payload", - ); - profile.add_breakdown( - format!("{label} owned internals"), - serialized_heap_estimate(value), - "estimate", - "deterministic serialized-size proxy for private sketch/container internals", - ); -} - fn aggop_label(op: &AggOp) -> String { match op { AggOp::Count(_) => "Count", @@ -639,6 +666,8 @@ fn aggop_label(op: &AggOp) -> String { #[cfg(test)] mod tests { use super::*; + use crate::agg_buffer::{HourOfDayHistogramState, SeasonalDeviationState}; + use crate::agg_geo::{GeoDistanceState, GeoSpreadState, GeoVelocityState}; use crate::agg_op::{AggKind, AggOp, AggOpDescriptor}; use crate::agg_state::{CountDistinctStateWrap, CountState, SumState}; use crate::agg_state_velocity::TrendResidualState; @@ -716,6 +745,42 @@ mod tests { assert!(profile.breakdown.iter().any(|b| b.label.contains("Box"))); } + #[test] + fn mem_usage_fixed_boxed_ops_do_not_use_serialized_proxy() { + let ops = [ + AggOp::HourOfDayHistogram(Box::::default()), + AggOp::SeasonalDeviation(Box::::default()), + AggOp::GeoVelocity(Box::new(GeoVelocityState::with_fields( + "lat".into(), + "lon".into(), + ))), + AggOp::GeoDistance(Box::new(GeoDistanceState::with_fields( + "lat".into(), + "lon".into(), + ))), + AggOp::GeoSpread(Box::new(GeoSpreadState::with_fields( + "lat".into(), + "lon".into(), + ))), + ]; + for op in ops { + let profile = op.mem_profile(); + assert!( + !profile.breakdown.iter().any(|entry| { + entry.kind == "estimate" || entry.label.contains("owned internals") + }), + "{} should use field-aware exact accounting: {:?}", + profile.label, + profile.breakdown + ); + assert!( + profile.breakdown.iter().any(|entry| entry.kind == "Box"), + "{} should still report the boxed payload", + profile.label + ); + } + } + #[test] fn mem_usage_count_distinct_reports_mode_specific_components() { let mut op = AggOp::new(&AggOpDescriptor { diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 5dcd33bd..81de6b1a 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -3,24 +3,24 @@ ## Workload Summary - Workload: `fraud` -- Events requested from generator: `2000` -- Events replayed from generator: `2000` +- Events requested from generator: `10000` +- Events replayed from generator: `10000` - Events by source: - - `Txn`: `2000` + - `Txn`: `10000` - Derivations discovered: `9` - Aggregate features discovered: `111` -- Active entity rows profiled: `5422` -- Bytes per active entity row p99: `26655` bytes +- Active entity rows profiled: `13533` +- Bytes per active entity row p99: `25794` bytes ## Per-Entity Table Footprint | Rank | Table | Source | group_by key | Active entities | Features/entity | Events applied | Stack p50 | Stack p99 | Stack max | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | Top contributor | |------|-------|--------|--------------|-----------------|-----------------|----------------|-----------|-----------|-----------|----------|----------|----------|-----------|-----------|-----------|-----------------| -| 1 | `TxnByUser` | `Txn` | `user_id` | 1982 | 62 | 2000 | 4960 | 4960 | 4960 | 21689 | 21697 | 22013 | 26649 | 26657 | 26973 | `amount_p95_24h` | -| 2 | `TxnByMerchant` | `Txn` | `merchant_id` | 863 | 4 | 2000 | 320 | 320 | 320 | 3096 | 3096 | 3096 | 3416 | 3416 | 3416 | `merchant_amount_p99_24h` | -| 3 | `TxnByIp` | `Txn` | `ip_address` | 862 | 8 | 2000 | 640 | 640 | 640 | 2224 | 2608 | 2896 | 2864 | 3248 | 3536 | `ip_top_users` | -| 4 | `TxnByCard` | `Txn` | `card_fp` | 854 | 8 | 2000 | 640 | 640 | 640 | 2216 | 2216 | 2216 | 2856 | 2856 | 2856 | `small_amt_burst_5m` | -| 5 | `TxnByDevice` | `Txn` | `device_id` | 861 | 6 | 2000 | 480 | 480 | 480 | 1104 | 1104 | 1104 | 1584 | 1584 | 1584 | `cards_per_device_24h` | +| 1 | `TxnByIp` | `Txn` | `ip_address` | 1000 | 8 | 10000 | 640 | 640 | 640 | 2992 | 60848 | 61136 | 3632 | 61488 | 61776 | `cards_per_ip_1h` | +| 2 | `TxnByDevice` | `Txn` | `device_id` | 1000 | 6 | 10000 | 480 | 480 | 480 | 1104 | 58192 | 58192 | 1584 | 58672 | 58672 | `cards_per_device_24h` | +| 3 | `TxnByMerchant` | `Txn` | `merchant_id` | 1000 | 4 | 10000 | 320 | 320 | 320 | 3096 | 31640 | 31640 | 3416 | 31960 | 31960 | `users_per_merchant_24h` | +| 4 | `TxnByCard` | `Txn` | `card_fp` | 1000 | 8 | 10000 | 640 | 640 | 640 | 2216 | 30760 | 30760 | 2856 | 31400 | 31400 | `merchants_per_card_24h` | +| 5 | `TxnByUser` | `Txn` | `user_id` | 9533 | 62 | 10000 | 4960 | 4960 | 4960 | 20494 | 20834 | 21434 | 25454 | 25794 | 26394 | `amount_p95_24h` | | 6 | `CardAddByDevice` | `CardAdd` | `device_id` | 0 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | | 7 | `LoginByUser` | `Login` | `user_id` | 0 | 8 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | | 8 | `RefundByUser` | `Refund` | `user_id` | 0 | 8 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | @@ -28,219 +28,107 @@ ## Per-Table Entity Details -### `TxnByUser` (`Txn` by `user_id`) +### `TxnByIp` (`Txn` by `ip_address`) #### Feature Columns Across Entities | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `amount_p95_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | -| `p50_amount_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | -| `p99_amount_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | -| `dist_from_home` | `distance_from_home` | `lifetime` | 80 | 1720 | 1720 | 1720 | 1800 | 1800 | 1800 | -| `reservoir_50` | `reservoir_sample` | `lifetime` | 80 | 1600 | 1600 | 1600 | 1680 | 1680 | 1680 | -| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 80 | 1424 | 1427 | 1427 | 1504 | 1507 | 1507 | -| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1344 | 1344 | 1424 | 1424 | 1424 | -| `device_seen` | `bloom_member` | `lifetime` | 80 | 1280 | 1280 | 1280 | 1360 | 1360 | 1360 | -| `burst_count_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | -| `top_merchants_24h` | `top_k` | `windowed` | 80 | 512 | 512 | 608 | 592 | 592 | 688 | -| `countries_distinct_7d` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `ips_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `merchants_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `mcc_entropy_24h` | `entropy` | `windowed` | 80 | 396 | 396 | 480 | 476 | 476 | 560 | -| `avg_amount_24h` | `mean` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `min_amount_24h` | `min` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `std_amount_24h` | `std` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `sum_amount_24h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_count_5m` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `var_amount_24h` | `var` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 80 | 252 | 252 | 252 | 332 | 332 | 332 | -| `geo_spread_24h` | `geo_spread` | `lifetime` | 80 | 215 | 217 | 246 | 295 | 297 | 326 | -| `event_mix_24h` | `event_type_mix` | `lifetime` | 80 | 208 | 208 | 288 | 288 | 288 | 368 | -| `geo_kmh` | `geo_velocity` | `lifetime` | 80 | 192 | 194 | 209 | 272 | 274 | 289 | -| `geo_dist_last` | `geo_distance` | `lifetime` | 80 | 177 | 179 | 193 | 257 | 259 | 273 | -| `unique_cells_24h` | `n_unique` | `lifetime` | 80 | 168 | 168 | 168 | 248 | 248 | 248 | -| `last_5_amounts` | `last_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | -| `recent_5_amts` | `most_recent_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | -| `first_5_merchants` | `first_n` | `lifetime` | 80 | 128 | 128 | 128 | 208 | 208 | 208 | -| `amount_lag1` | `lag` | `lifetime` | 80 | 64 | 64 | 64 | 144 | 144 | 144 | -| `geo_entropy_24h` | `entropy` | `lifetime` | 80 | 56 | 56 | 56 | 136 | 136 | 136 | -| `time_since_last_5` | `time_since_last_n` | `lifetime` | 80 | 40 | 40 | 40 | 120 | 120 | 120 | -| `age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_delta` | `delta_from_prev` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_ewma_1h` | `ewma` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_ewvar_1h` | `ewvar` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_outliers_5m` | `outlier_count` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_rate_5m` | `rate_of_change` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_trend_5m` | `trend` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_twa_5m` | `twa` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `amount_z_score` | `z_score` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `decline_streak` | `negative_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `device_change_count_5m` | `value_change_count` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `first_amount` | `first` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `first_in_24h` | `first_seen_in_window` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `has_seen` | `has_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `last_amount` | `last` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `last_seen` | `last_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `max_amount_lifetime` | `max` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `max_streak` | `max_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `sum_amount_lifetime` | `sum` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `time_since_last` | `time_since` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `txn_count_lifetime` | `count` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `txn_streak` | `streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `cards_per_ip_1h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `users_per_ip_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `ip_top_users` | `top_k` | `windowed` | 80 | 1376 | 2144 | 2432 | 1456 | 2224 | 2512 | +| `amount_sum_per_ip_1h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_per_ip_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_per_ip_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `ip_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `ip_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | #### Largest Entity Rows | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `k00029943` | 2 | 4960 | 22013 | 26973 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00055008` | 2 | 4960 | 22013 | 26973 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00067574` | 2 | 4960 | 22010 | 26970 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00070333` | 2 | 4960 | 22009 | 26969 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00022821` | 2 | 4960 | 22008 | 26968 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `s122` | 21 | 640 | 61136 | 61776 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2512 bytes | +| `s226` | 21 | 640 | 61136 | 61776 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2512 bytes | +| `s870` | 20 | 640 | 61040 | 61680 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2416 bytes | +| `s917` | 20 | 640 | 61040 | 61680 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2416 bytes | +| `s380` | 19 | 640 | 60944 | 61584 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2320 bytes | -#### Feature Breakdown For Largest Entity `k00029943` +#### Feature Breakdown For Largest Entity `s122` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `amount_p95_24h` | `quantile` | `windowed` | 2 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `p50_amount_24h` | `quantile` | `windowed` | 2 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `p99_amount_24h` | `quantile` | `windowed` | 2 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `dist_from_home` | `distance_from_home` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 1720 | 1800 | -| `reservoir_50` | `reservoir_sample` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 1600 | 1680 | -| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 1426 | 1506 | -| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 2 | 80 | 80 | 24 | 56 | 1344 | 1424 | -| `device_seen` | `bloom_member` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 1280 | 1360 | -| `burst_count_5m` | `burst_count` | `windowed` | 2 | 80 | 80 | 72 | 8 | 1024 | 1104 | -| `top_merchants_24h` | `top_k` | `windowed` | 2 | 80 | 80 | 8 | 72 | 608 | 688 | -| `mcc_entropy_24h` | `entropy` | `windowed` | 2 | 80 | 80 | 8 | 72 | 480 | 560 | -| `countries_distinct_7d` | `n_unique` | `windowed` | 2 | 80 | 80 | 8 | 72 | 424 | 504 | -| `ips_distinct_24h` | `n_unique` | `windowed` | 2 | 80 | 80 | 8 | 72 | 424 | 504 | -| `merchants_distinct_24h` | `n_unique` | `windowed` | 2 | 80 | 80 | 8 | 72 | 424 | 504 | -| `event_mix_24h` | `event_type_mix` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 288 | 368 | -| `avg_amount_24h` | `mean` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `min_amount_24h` | `min` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `std_amount_24h` | `std` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `sum_amount_24h` | `sum` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_count_1h` | `count` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_count_24h` | `count` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_count_5m` | `count` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `var_amount_24h` | `var` | `windowed` | 2 | 80 | 80 | 8 | 72 | 256 | 336 | -| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 252 | 332 | -| `geo_spread_24h` | `geo_spread` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 246 | 326 | -| `geo_kmh` | `geo_velocity` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 208 | 288 | -| `geo_dist_last` | `geo_distance` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 193 | 273 | -| `unique_cells_24h` | `n_unique` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 168 | 248 | -| `last_5_amounts` | `last_n` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 160 | 240 | -| `recent_5_amts` | `most_recent_n` | `lifetime` | 2 | 80 | 80 | 48 | 32 | 160 | 240 | -| `first_5_merchants` | `first_n` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 128 | 208 | -| `amount_lag1` | `lag` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 64 | 144 | -| `geo_entropy_24h` | `entropy` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 56 | 136 | -| `time_since_last_5` | `time_since_last_n` | `lifetime` | 2 | 80 | 80 | 40 | 40 | 40 | 120 | -| `age` | `age` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_delta` | `delta_from_prev` | `lifetime` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | -| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | -| `amount_ewma_1h` | `ewma` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_ewvar_1h` | `ewvar` | `lifetime` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | -| `amount_outliers_5m` | `outlier_count` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | -| `amount_rate_5m` | `rate_of_change` | `windowed` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_trend_5m` | `trend` | `windowed` | 2 | 80 | 80 | 48 | 32 | 0 | 80 | -| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 2 | 80 | 80 | 72 | 8 | 0 | 80 | -| `amount_twa_5m` | `twa` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | -| `amount_z_score` | `z_score` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | -| `decline_streak` | `negative_streak` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | -| `device_change_count_5m` | `value_change_count` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | -| `first_amount` | `first` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `first_in_24h` | `first_seen_in_window` | `windowed` | 2 | 80 | 80 | 24 | 56 | 0 | 80 | -| `first_seen` | `first_seen` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `has_seen` | `has_seen` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 2 | 80 | 80 | 40 | 40 | 0 | 80 | -| `last_amount` | `last` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `last_seen` | `last_seen` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `max_amount_lifetime` | `max` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `max_streak` | `max_streak` | `lifetime` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | -| `sum_amount_lifetime` | `sum` | `lifetime` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | -| `time_since_last` | `time_since` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `txn_count_lifetime` | `count` | `lifetime` | 2 | 80 | 80 | 8 | 72 | 0 | 80 | -| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 2 | 80 | 80 | 32 | 48 | 0 | 80 | -| `txn_streak` | `streak` | `lifetime` | 2 | 80 | 80 | 16 | 64 | 0 | 80 | +| `cards_per_ip_1h` | `n_unique` | `windowed` | 21 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `users_per_ip_24h` | `n_unique` | `windowed` | 21 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `ip_top_users` | `top_k` | `windowed` | 21 | 80 | 80 | 8 | 72 | 2432 | 2512 | +| `amount_sum_per_ip_1h` | `sum` | `windowed` | 21 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_ip_1h` | `count` | `windowed` | 21 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_ip_24h` | `count` | `windowed` | 21 | 80 | 80 | 8 | 72 | 256 | 336 | +| `ip_age` | `age` | `lifetime` | 21 | 80 | 80 | 32 | 48 | 0 | 80 | +| `ip_first_seen` | `first_seen` | `lifetime` | 21 | 80 | 80 | 32 | 48 | 0 | 80 | -### `TxnByMerchant` (`Txn` by `merchant_id`) +### `TxnByDevice` (`Txn` by `device_id`) #### Feature Columns Across Entities | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `merchant_amount_p99_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | -| `users_per_merchant_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `txn_per_merchant_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `merchant_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `cards_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `users_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `device_txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `device_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `device_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `device_last_seen` | `last_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | #### Largest Entity Rows | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s470` | 9 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | -| `s176` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | -| `s278` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | -| `s387` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | -| `s507` | 7 | 320 | 3096 | 3416 | `merchant_amount_p99_24h`=2496 bytes, `users_per_merchant_24h`=504 bytes, `txn_per_merchant_24h`=336 bytes | +| `s960` | 24 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s186` | 22 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s741` | 22 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s549` | 21 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s939` | 21 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | -#### Feature Breakdown For Largest Entity `s470` +#### Feature Breakdown For Largest Entity `s960` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `merchant_amount_p99_24h` | `quantile` | `windowed` | 9 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `users_per_merchant_24h` | `n_unique` | `windowed` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | -| `txn_per_merchant_24h` | `count` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | -| `merchant_first_seen` | `first_seen` | `lifetime` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | +| `cards_per_device_24h` | `n_unique` | `windowed` | 24 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `users_per_device_24h` | `n_unique` | `windowed` | 24 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `device_txn_count_24h` | `count` | `windowed` | 24 | 80 | 80 | 8 | 72 | 256 | 336 | +| `device_age` | `age` | `lifetime` | 24 | 80 | 80 | 32 | 48 | 0 | 80 | +| `device_first_seen` | `first_seen` | `lifetime` | 24 | 80 | 80 | 32 | 48 | 0 | 80 | +| `device_last_seen` | `last_seen` | `lifetime` | 24 | 80 | 80 | 32 | 48 | 0 | 80 | -### `TxnByIp` (`Txn` by `ip_address`) +### `TxnByMerchant` (`Txn` by `merchant_id`) #### Feature Columns Across Entities | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `ip_top_users` | `top_k` | `windowed` | 80 | 608 | 992 | 1280 | 688 | 1072 | 1360 | -| `cards_per_ip_1h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `users_per_ip_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `amount_sum_per_ip_1h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_per_ip_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_per_ip_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `ip_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `ip_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `users_per_merchant_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `merchant_amount_p99_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `txn_per_merchant_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `merchant_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | #### Largest Entity Rows | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s389` | 9 | 640 | 2896 | 3536 | `ip_top_users`=1360 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | -| `s122` | 8 | 640 | 2800 | 3440 | `ip_top_users`=1264 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | -| `s466` | 8 | 640 | 2800 | 3440 | `ip_top_users`=1264 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | -| `s132` | 7 | 640 | 2704 | 3344 | `ip_top_users`=1168 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | -| `s226` | 7 | 640 | 2704 | 3344 | `ip_top_users`=1168 bytes, `cards_per_ip_1h`=504 bytes, `users_per_ip_24h`=504 bytes | +| `s201` | 23 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s370` | 21 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s494` | 21 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s570` | 21 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s591` | 20 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | -#### Feature Breakdown For Largest Entity `s389` +#### Feature Breakdown For Largest Entity `s201` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `ip_top_users` | `top_k` | `windowed` | 9 | 80 | 80 | 8 | 72 | 1280 | 1360 | -| `cards_per_ip_1h` | `n_unique` | `windowed` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | -| `users_per_ip_24h` | `n_unique` | `windowed` | 9 | 80 | 80 | 8 | 72 | 424 | 504 | -| `amount_sum_per_ip_1h` | `sum` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_ip_1h` | `count` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_ip_24h` | `count` | `windowed` | 9 | 80 | 80 | 8 | 72 | 256 | 336 | -| `ip_age` | `age` | `lifetime` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | -| `ip_first_seen` | `first_seen` | `lifetime` | 9 | 80 | 80 | 32 | 48 | 0 | 80 | +| `users_per_merchant_24h` | `n_unique` | `windowed` | 23 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `merchant_amount_p99_24h` | `quantile` | `windowed` | 23 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `txn_per_merchant_24h` | `count` | `windowed` | 23 | 80 | 80 | 8 | 72 | 256 | 336 | +| `merchant_first_seen` | `first_seen` | `lifetime` | 23 | 80 | 80 | 32 | 48 | 0 | 80 | ### `TxnByCard` (`Txn` by `card_fp`) @@ -248,8 +136,8 @@ | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| +| `merchants_per_card_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | | `small_amt_burst_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | -| `merchants_per_card_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | | `decline_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `txn_per_card_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `txn_per_card_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | @@ -261,58 +149,170 @@ | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s409` | 10 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | -| `s179` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | -| `s42` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | -| `s450` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | -| `s896` | 7 | 640 | 2216 | 2856 | `small_amt_burst_5m`=1104 bytes, `merchants_per_card_24h`=504 bytes, `decline_count_1h`=336 bytes | +| `s774` | 26 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | +| `s395` | 23 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | +| `s546` | 23 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | +| `s896` | 23 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | +| `s505` | 21 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | -#### Feature Breakdown For Largest Entity `s409` +#### Feature Breakdown For Largest Entity `s774` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `small_amt_burst_5m` | `burst_count` | `windowed` | 10 | 80 | 80 | 72 | 8 | 1024 | 1104 | -| `merchants_per_card_24h` | `n_unique` | `windowed` | 10 | 80 | 80 | 8 | 72 | 424 | 504 | -| `decline_count_1h` | `count` | `windowed` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_card_1h` | `count` | `windowed` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_card_24h` | `count` | `windowed` | 10 | 80 | 80 | 8 | 72 | 256 | 336 | -| `card_age` | `age` | `lifetime` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | -| `card_first_seen` | `first_seen` | `lifetime` | 10 | 80 | 80 | 32 | 48 | 0 | 80 | -| `decline_streak_card` | `negative_streak` | `lifetime` | 10 | 80 | 80 | 8 | 72 | 0 | 80 | +| `merchants_per_card_24h` | `n_unique` | `windowed` | 26 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `small_amt_burst_5m` | `burst_count` | `windowed` | 26 | 80 | 80 | 72 | 8 | 1024 | 1104 | +| `decline_count_1h` | `count` | `windowed` | 26 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_card_1h` | `count` | `windowed` | 26 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_per_card_24h` | `count` | `windowed` | 26 | 80 | 80 | 8 | 72 | 256 | 336 | +| `card_age` | `age` | `lifetime` | 26 | 80 | 80 | 32 | 48 | 0 | 80 | +| `card_first_seen` | `first_seen` | `lifetime` | 26 | 80 | 80 | 32 | 48 | 0 | 80 | +| `decline_streak_card` | `negative_streak` | `lifetime` | 26 | 80 | 80 | 8 | 72 | 0 | 80 | -### `TxnByDevice` (`Txn` by `device_id`) +### `TxnByUser` (`Txn` by `user_id`) #### Feature Columns Across Entities | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `cards_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `users_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `device_txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `device_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `device_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | -| `device_last_seen` | `last_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_p95_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `p50_amount_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `p99_amount_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | +| `dist_from_home` | `distance_from_home` | `lifetime` | 80 | 1720 | 1720 | 1720 | 1800 | 1800 | 1800 | +| `reservoir_50` | `reservoir_sample` | `lifetime` | 80 | 1600 | 1600 | 1600 | 1680 | 1680 | 1680 | +| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1344 | 1344 | 1424 | 1424 | 1424 | +| `device_seen` | `bloom_member` | `lifetime` | 80 | 1280 | 1280 | 1280 | 1360 | 1360 | 1360 | +| `burst_count_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | +| `top_merchants_24h` | `top_k` | `windowed` | 80 | 512 | 608 | 800 | 592 | 688 | 880 | +| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 80 | 600 | 600 | 600 | 680 | 680 | 680 | +| `mcc_entropy_24h` | `entropy` | `windowed` | 80 | 396 | 480 | 648 | 476 | 560 | 728 | +| `countries_distinct_7d` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `ips_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `merchants_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | +| `txn_count_5m` | `count` | `windowed` | 80 | 256 | 336 | 416 | 336 | 416 | 496 | +| `event_mix_24h` | `event_type_mix` | `lifetime` | 80 | 208 | 288 | 448 | 288 | 368 | 528 | +| `avg_amount_24h` | `mean` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `min_amount_24h` | `min` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `std_amount_24h` | `std` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `sum_amount_24h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `var_amount_24h` | `var` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 80 | 192 | 192 | 192 | 272 | 272 | 272 | +| `unique_cells_24h` | `n_unique` | `lifetime` | 80 | 168 | 168 | 168 | 248 | 248 | 248 | +| `last_5_amounts` | `last_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | +| `recent_5_amts` | `most_recent_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | +| `first_5_merchants` | `first_n` | `lifetime` | 80 | 128 | 128 | 128 | 208 | 208 | 208 | +| `geo_kmh` | `geo_velocity` | `lifetime` | 80 | 94 | 94 | 94 | 174 | 174 | 174 | +| `geo_spread_24h` | `geo_spread` | `lifetime` | 80 | 94 | 94 | 94 | 174 | 174 | 174 | +| `geo_dist_last` | `geo_distance` | `lifetime` | 80 | 86 | 86 | 86 | 166 | 166 | 166 | +| `amount_lag1` | `lag` | `lifetime` | 80 | 64 | 64 | 64 | 144 | 144 | 144 | +| `geo_entropy_24h` | `entropy` | `lifetime` | 80 | 56 | 56 | 56 | 136 | 136 | 136 | +| `time_since_last_5` | `time_since_last_n` | `lifetime` | 80 | 40 | 40 | 40 | 120 | 120 | 120 | +| `age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_delta` | `delta_from_prev` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_ewma_1h` | `ewma` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_ewvar_1h` | `ewvar` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_outliers_5m` | `outlier_count` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_rate_5m` | `rate_of_change` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_trend_5m` | `trend` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_twa_5m` | `twa` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `amount_z_score` | `z_score` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `decline_streak` | `negative_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `device_change_count_5m` | `value_change_count` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `first_amount` | `first` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `first_in_24h` | `first_seen_in_window` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `has_seen` | `has_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `last_amount` | `last` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `last_seen` | `last_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `max_amount_lifetime` | `max` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `max_streak` | `max_streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `sum_amount_lifetime` | `sum` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `time_since_last` | `time_since` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `txn_count_lifetime` | `count` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | +| `txn_streak` | `streak` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | #### Largest Entity Rows | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s377` | 7 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | -| `s717` | 7 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | -| `s743` | 7 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | -| `s107` | 6 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | -| `s171` | 6 | 480 | 1104 | 1584 | `cards_per_device_24h`=504 bytes, `users_per_device_24h`=504 bytes, `device_txn_count_24h`=336 bytes | +| `k00032049` | 4 | 4960 | 21434 | 26394 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00045411` | 3 | 4960 | 21174 | 26134 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00011780` | 3 | 4960 | 21094 | 26054 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00017976` | 3 | 4960 | 21094 | 26054 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00035736` | 3 | 4960 | 21094 | 26054 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -#### Feature Breakdown For Largest Entity `s377` +#### Feature Breakdown For Largest Entity `k00032049` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `cards_per_device_24h` | `n_unique` | `windowed` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | -| `users_per_device_24h` | `n_unique` | `windowed` | 7 | 80 | 80 | 8 | 72 | 424 | 504 | -| `device_txn_count_24h` | `count` | `windowed` | 7 | 80 | 80 | 8 | 72 | 256 | 336 | -| `device_age` | `age` | `lifetime` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | -| `device_first_seen` | `first_seen` | `lifetime` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | -| `device_last_seen` | `last_seen` | `lifetime` | 7 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_p95_24h` | `quantile` | `windowed` | 4 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `p50_amount_24h` | `quantile` | `windowed` | 4 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `p99_amount_24h` | `quantile` | `windowed` | 4 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `dist_from_home` | `distance_from_home` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 1720 | 1800 | +| `reservoir_50` | `reservoir_sample` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 1600 | 1680 | +| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 4 | 80 | 80 | 24 | 56 | 1344 | 1424 | +| `device_seen` | `bloom_member` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 1280 | 1360 | +| `burst_count_5m` | `burst_count` | `windowed` | 4 | 80 | 80 | 72 | 8 | 1024 | 1104 | +| `top_merchants_24h` | `top_k` | `windowed` | 4 | 80 | 80 | 8 | 72 | 800 | 880 | +| `mcc_entropy_24h` | `entropy` | `windowed` | 4 | 80 | 80 | 8 | 72 | 648 | 728 | +| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 600 | 680 | +| `event_mix_24h` | `event_type_mix` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 448 | 528 | +| `countries_distinct_7d` | `n_unique` | `windowed` | 4 | 80 | 80 | 8 | 72 | 424 | 504 | +| `ips_distinct_24h` | `n_unique` | `windowed` | 4 | 80 | 80 | 8 | 72 | 424 | 504 | +| `merchants_distinct_24h` | `n_unique` | `windowed` | 4 | 80 | 80 | 8 | 72 | 424 | 504 | +| `txn_count_5m` | `count` | `windowed` | 4 | 80 | 80 | 8 | 72 | 416 | 496 | +| `avg_amount_24h` | `mean` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `min_amount_24h` | `min` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `std_amount_24h` | `std` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `sum_amount_24h` | `sum` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_count_1h` | `count` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_count_24h` | `count` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `var_amount_24h` | `var` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | +| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 192 | 272 | +| `unique_cells_24h` | `n_unique` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 168 | 248 | +| `last_5_amounts` | `last_n` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 160 | 240 | +| `recent_5_amts` | `most_recent_n` | `lifetime` | 4 | 80 | 80 | 48 | 32 | 160 | 240 | +| `first_5_merchants` | `first_n` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 128 | 208 | +| `geo_kmh` | `geo_velocity` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 94 | 174 | +| `geo_spread_24h` | `geo_spread` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 94 | 174 | +| `geo_dist_last` | `geo_distance` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 86 | 166 | +| `amount_lag1` | `lag` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 64 | 144 | +| `geo_entropy_24h` | `entropy` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 56 | 136 | +| `time_since_last_5` | `time_since_last_n` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 40 | 120 | +| `age` | `age` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_delta` | `delta_from_prev` | `lifetime` | 4 | 80 | 80 | 24 | 56 | 0 | 80 | +| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 4 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_ewma_1h` | `ewma` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_ewvar_1h` | `ewvar` | `lifetime` | 4 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_outliers_5m` | `outlier_count` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | +| `amount_rate_5m` | `rate_of_change` | `windowed` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_trend_5m` | `trend` | `windowed` | 4 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 4 | 80 | 80 | 72 | 8 | 0 | 80 | +| `amount_twa_5m` | `twa` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | +| `amount_z_score` | `z_score` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | +| `decline_streak` | `negative_streak` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 0 | 80 | +| `device_change_count_5m` | `value_change_count` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | +| `first_amount` | `first` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `first_in_24h` | `first_seen_in_window` | `windowed` | 4 | 80 | 80 | 24 | 56 | 0 | 80 | +| `first_seen` | `first_seen` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `has_seen` | `has_seen` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | +| `last_amount` | `last` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `last_seen` | `last_seen` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `max_amount_lifetime` | `max` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `max_streak` | `max_streak` | `lifetime` | 4 | 80 | 80 | 16 | 64 | 0 | 80 | +| `sum_amount_lifetime` | `sum` | `lifetime` | 4 | 80 | 80 | 16 | 64 | 0 | 80 | +| `time_since_last` | `time_since` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `txn_count_lifetime` | `count` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 0 | 80 | +| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | +| `txn_streak` | `streak` | `lifetime` | 4 | 80 | 80 | 16 | 64 | 0 | 80 | ### `CardAddByDevice` (`CardAdd` by `device_id`) @@ -332,79 +332,57 @@ No active entity rows. Configured features: `4`. The workload generator emitted ## Top 5 Offenders -### 1. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` +One heaviest entity-feature example per unique op. -- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` -- Entity key: `s470` -- Entity events: `9` -- Key path: `merchant_id` -- Events applied: `9` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 -- Shape: `windowed` (1d) -- Recommendation: restructure only if lazy bucket materialization still dominates -- Breakdown rollup: - - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) -- Raw breakdown: - - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - -### 2. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` +### 1. `Txn` / `TxnByCard` / `merchants_per_card_24h` / `n_unique` -- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` -- Entity key: `s176` -- Entity events: `7` -- Key path: `merchant_id` -- Events applied: `7` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 +- Path: `Txn` -> `TxnByCard` -> `merchants_per_card_24h` -> `n_unique` -> `windowed` +- Entity key: `s774` +- Entity events: `26` +- Key path: `card_fp` +- Events applied: `26` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=28968 total=29048 - Shape: `windowed` (1d) -- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) + - `CountDistinct hash-set slots across buckets`: 28672 bytes (HashSet, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) + - `Box across buckets`: 40 bytes (Box, summed across active window buckets) - Raw breakdown: - - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) -### 3. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` +### 2. `Txn` / `TxnByIp` / `ip_top_users` / `top_k` -- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` -- Entity key: `s278` -- Entity events: `7` -- Key path: `merchant_id` -- Events applied: `7` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 +- Path: `Txn` -> `TxnByIp` -> `ip_top_users` -> `top_k` -> `windowed` +- Entity key: `s122` +- Entity events: `21` +- Key path: `ip_address` +- Events applied: `21` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2432 total=2512 - Shape: `windowed` (1d) -- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) + - `TopK exact BTreeMap entries across buckets`: 2016 bytes (BTreeMap, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 112 bytes (Box, summed across active window buckets) + - `Box across buckets`: 160 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - Raw breakdown: - - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) + - `Windowed bucket 0 / TopK exact BTreeMap entries`: 2016 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) + - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) -### 4. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` +### 3. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` - Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` -- Entity key: `s387` -- Entity events: `7` +- Entity key: `s201` +- Entity events: `23` - Key path: `merchant_id` -- Events applied: `7` +- Events applied: `23` - Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) -- Recommendation: restructure only if lazy bucket materialization still dominates - Breakdown rollup: - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) @@ -416,33 +394,37 @@ No active entity rows. Configured features: `4`. The workload generator emitted - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) -### 5. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` - -- Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` -- Entity key: `s507` -- Entity events: `7` -- Key path: `merchant_id` -- Events applied: `7` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 -- Shape: `windowed` (1d) -- Recommendation: restructure only if lazy bucket materialization still dominates -- Breakdown rollup: - - `Percentile exact samples across buckets`: 2048 bytes (Vec, summed across active window buckets) - - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Box across buckets`: 112 bytes (Box, summed across active window buckets) - - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) -- Raw breakdown: - - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 / Box`: 112 bytes (Box, heap allocation for boxed Percentile wrapper) - - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) +### 4. `Txn` / `TxnByUser` / `dist_from_home` / `distance_from_home` + +- Path: `Txn` -> `TxnByUser` -> `dist_from_home` -> `distance_from_home` -> `lifetime` +- Entity key: `k00032049` +- Entity events: `4` +- Key path: `user_id` +- Events applied: `4` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=1720 total=1800 +- Shape: `lifetime` +- Breakdown: + - `DistanceFromHome coordinate buffer`: 1600 bytes (Vec, capacity * size_of::<(f64, f64)>()) + - `Box`: 120 bytes (Box, heap allocation for boxed payload) + +### 5. `Txn` / `TxnByUser` / `reservoir_50` / `reservoir_sample` + +- Path: `Txn` -> `TxnByUser` -> `reservoir_50` -> `reservoir_sample` -> `lifetime` +- Entity key: `k00032049` +- Entity events: `4` +- Key path: `user_id` +- Events applied: `4` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=40 slack_bytes=40) heap=1600 total=1680 +- Shape: `lifetime` +- Breakdown: + - `ReservoirSample reservoir`: 1600 bytes (Vec, capacity * size_of::()) ## Metrics Coherence - `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile bytes-per-active-entity-row p99: `26655` bytes +- Profile bytes-per-active-entity-row p99: `25794` bytes - Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 19655 bytes; file sibling work to replace the static placeholder with live sampling. +- Assertion: bytes_per_entity_p99 diverged by 18794 bytes; file sibling work to replace the static placeholder with live sampling. ## Notes @@ -451,4 +433,4 @@ No active entity rows. Configured features: `4`. The workload generator emitted - `payload_bytes` is the active variant payload inside the enum slot. For boxed variants this is the inline `Box` pointer, while the boxed pointee remains in `heap_bytes`. - `slack_bytes` is unused capacity in the fixed-size `AggOp` enum slot: `enum_slot_bytes - payload_bytes`. - Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. -- Primary grain is `derivation table -> entity row -> feature column`; op/shape rows remain as secondary diagnostics for implementation-level hotspots. +- Primary grain is `derivation table -> entity row -> feature column`; top offenders list one concrete entity-feature row per unique op. From f2ffaad7ecce35e66d017be6f3de4d16c586acb6 Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Sun, 24 May 2026 16:11:55 -0400 Subject: [PATCH 8/9] Removed some reports --- memory-profile-adtech.md | 97 --------------------------- memory-profile-ecommerce.md | 129 ------------------------------------ memory-profile-medium.md | 68 ------------------- 3 files changed, 294 deletions(-) delete mode 100644 memory-profile-adtech.md delete mode 100644 memory-profile-ecommerce.md delete mode 100644 memory-profile-medium.md diff --git a/memory-profile-adtech.md b/memory-profile-adtech.md deleted file mode 100644 index af1ea61f..00000000 --- a/memory-profile-adtech.md +++ /dev/null @@ -1,97 +0,0 @@ -# AggOp Memory Profile: fraud-team - -## Workload Summary - -- Workload: `adtech` -- Events replayed per op: `2000` -- Derivations discovered: `1` -- Aggregate features discovered: `7` -- Per-entity structural estimate: `1122600` bytes - -## Sorted Op Table - -| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | -|------|----|-------|-------------|------------|-------------| -| 1 | `n_unique` | `windowed` | 80 | 1037960 | 1038040 | -| 2 | `quantile` | `windowed` | 80 | 84080 | 84160 | -| 3 | `count` | `lifetime` | 80 | 0 | 80 | -| 4 | `max` | `lifetime` | 80 | 0 | 80 | -| 5 | `mean` | `lifetime` | 80 | 0 | 80 | -| 6 | `min` | `lifetime` | 80 | 0 | 80 | -| 7 | `sum` | `lifetime` | 80 | 0 | 80 | - -## Top 5 Offenders - -### 1. `TxnAgg` / `merchants_distinct_1h` / `n_unique` - -- Bytes: stack=80 heap=1037960 total=1038040 -- Shape: `windowed` (1h) -- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately -- Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) -- Raw breakdown: - - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - -### 2. `TxnAgg` / `amount_p99_1h` / `quantile` - -- Bytes: stack=80 heap=84080 total=84160 -- Shape: `windowed` (1h) -- Recommendation: restructure only if lazy bucket materialization still dominates -- Breakdown rollup: - - `Percentile exact samples across buckets`: 75776 bytes (Vec, summed across active window buckets) - - `Box across buckets`: 4144 bytes (Box, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) -- Raw breakdown: - - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 1 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 10 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 11 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 12 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 13 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 14 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 15 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - -### 3. `TxnAgg` / `avg_amt` / `mean` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; scalar state spends only the shared AggOp slot -- Breakdown: - -### 4. `TxnAgg` / `cnt` / `count` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; scalar state spends only the shared AggOp slot -- Breakdown: - -### 5. `TxnAgg` / `max_amt` / `max` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; no targeted restructuring until workload ranking justifies it -- Breakdown: - -## Metrics Coherence - -- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile per-entity estimate: `1122600` bytes -- Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 1115600 bytes; file sibling work to replace the static placeholder with live sampling. - -## Notes - -- `stack_bytes` is the inline `AggOp` enum slot for each feature. -- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. diff --git a/memory-profile-ecommerce.md b/memory-profile-ecommerce.md deleted file mode 100644 index 002bd1e3..00000000 --- a/memory-profile-ecommerce.md +++ /dev/null @@ -1,129 +0,0 @@ -# AggOp Memory Profile: fraud-team - -## Workload Summary - -- Workload: `ecommerce` -- Events replayed per op: `2000` -- Derivations discovered: `1` -- Aggregate features discovered: `20` -- Per-entity structural estimate: `1333232` bytes - -## Sorted Op Table - -| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | -|------|----|-------|-------------|------------|-------------| -| 1 | `n_unique` | `windowed` | 80 | 1037960 | 1038040 | -| 2 | `top_k` | `windowed` | 80 | 202080 | 202160 | -| 3 | `quantile` | `windowed` | 80 | 84080 | 84160 | -| 4 | `entropy` | `windowed` | 80 | 6232 | 6312 | -| 5 | `bloom_member` | `lifetime` | 80 | 1280 | 1360 | -| 6 | `max` | `lifetime` | 240 | 0 | 240 | -| 7 | `mean` | `lifetime` | 240 | 0 | 240 | -| 8 | `min` | `lifetime` | 240 | 0 | 240 | -| 9 | `sum` | `lifetime` | 240 | 0 | 240 | -| 10 | `count` | `lifetime` | 80 | 0 | 80 | -| 11 | `std` | `lifetime` | 80 | 0 | 80 | -| 12 | `var` | `lifetime` | 80 | 0 | 80 | - -## Top 5 Offenders - -### 1. `TxnAgg` / `merchants_distinct_1h` / `n_unique` - -- Bytes: stack=80 heap=1037960 total=1038040 -- Shape: `windowed` (1h) -- Recommendation: keep for now; quantify sketch precision and window bucket fanout separately -- Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 1032192 bytes (HashSet, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 1480 bytes (Box, summed across active window buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `CountDistinct exact-array values across buckets`: 128 bytes (Vec, summed across active window buckets) -- Raw breakdown: - - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 10 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 11 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 12 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 13 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 14 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 15 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - - `Windowed bucket 16 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - -### 2. `TxnAgg` / `top_merchants_1h` / `top_k` - -- Bytes: stack=80 heap=202080 total=202160 -- Shape: `windowed` (1h) -- Recommendation: restructure only if lazy bucket materialization still dominates -- Breakdown rollup: - - `TopK exact BTreeMap entries across buckets`: 192000 bytes (BTreeMap, summed across active window buckets) - - `Box across buckets`: 5920 bytes (Box, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) -- Raw breakdown: - - `Windowed bucket 11 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 15 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 19 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 23 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 27 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 3 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 31 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - - `Windowed bucket 35 / TopK exact BTreeMap entries`: 5472 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - -### 3. `TxnAgg` / `amount_p99_1h` / `quantile` - -- Bytes: stack=80 heap=84080 total=84160 -- Shape: `windowed` (1h) -- Recommendation: restructure only if lazy bucket materialization still dominates -- Breakdown rollup: - - `Percentile exact samples across buckets`: 75776 bytes (Vec, summed across active window buckets) - - `Box across buckets`: 4144 bytes (Box, summed across active window buckets) - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) -- Raw breakdown: - - `Windowed bucket 0 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 1 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 10 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 11 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 12 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 13 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 14 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - - `Windowed bucket 15 / Percentile exact samples`: 2048 bytes (Vec, capacity * size_of::() for exact percentile samples) - -### 4. `TxnAgg` / `category_entropy_1h` / `entropy` - -- Bytes: stack=80 heap=6232 total=6312 -- Shape: `windowed` (1h) -- Recommendation: restructure only if lazy bucket materialization still dominates -- Breakdown rollup: - - `Windowed bucket shell overhead`: 2960 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 2072 bytes (Box, summed across active window buckets) - - `Windowed wrapper overhead`: 1200 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) -- Raw breakdown: - - `WindowedOp spilled bucket SmallVec`: 1024 bytes (SmallVec, spilled capacity * size_of::<(i64, Box)>()) - - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 10 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 11 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 12 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - - `Windowed bucket 13 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - -### 5. `TxnAgg` / `device_seen` / `bloom_member` - -- Bytes: stack=80 heap=1280 total=1360 -- Shape: `lifetime` -- Recommendation: keep for now; quantify sparse-to-dense sketch options next -- Breakdown: - - `Bloom filter words`: 1232 bytes (Vec, capacity * size_of::() for bloom bit-array storage) - - `Box`: 48 bytes (Box, heap allocation for boxed Bloom wrapper) - -## Metrics Coherence - -- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile per-entity estimate: `1333232` bytes -- Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 1326232 bytes; file sibling work to replace the static placeholder with live sampling. - -## Notes - -- `stack_bytes` is the inline `AggOp` enum slot for each feature. -- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. diff --git a/memory-profile-medium.md b/memory-profile-medium.md deleted file mode 100644 index 210671cc..00000000 --- a/memory-profile-medium.md +++ /dev/null @@ -1,68 +0,0 @@ -# AggOp Memory Profile: fraud-team - -## Workload Summary - -- Workload: `medium` -- Events replayed per op: `2000` -- Derivations discovered: `1` -- Aggregate features discovered: `5` -- Per-entity structural estimate: `400` bytes - -## Sorted Op Table - -| Rank | Op | Shape | Stack bytes | Heap bytes | Total bytes | -|------|----|-------|-------------|------------|-------------| -| 1 | `count` | `lifetime` | 80 | 0 | 80 | -| 2 | `max` | `lifetime` | 80 | 0 | 80 | -| 3 | `mean` | `lifetime` | 80 | 0 | 80 | -| 4 | `min` | `lifetime` | 80 | 0 | 80 | -| 5 | `sum` | `lifetime` | 80 | 0 | 80 | - -## Top 5 Offenders - -### 1. `TxnAgg` / `avg_amt` / `mean` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; scalar state spends only the shared AggOp slot -- Breakdown: - -### 2. `TxnAgg` / `cnt` / `count` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; scalar state spends only the shared AggOp slot -- Breakdown: - -### 3. `TxnAgg` / `max_amt` / `max` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; no targeted restructuring until workload ranking justifies it -- Breakdown: - -### 4. `TxnAgg` / `min_amt` / `min` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; no targeted restructuring until workload ranking justifies it -- Breakdown: - -### 5. `TxnAgg` / `sum_amt` / `sum` - -- Bytes: stack=80 heap=0 total=80 -- Shape: `lifetime` -- Recommendation: keep; scalar state spends only the shared AggOp slot -- Breakdown: - -## Metrics Coherence - -- `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile per-entity estimate: `400` bytes -- Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 6600 bytes; file sibling work to replace the static placeholder with live sampling. - -## Notes - -- `stack_bytes` is the inline `AggOp` enum slot for each feature. -- Heap entries are deterministic structural counts; map/table allocator overhead is labeled as an estimate. From f2bd86ef905caf318378c27d2542af9e5f63047f Mon Sep 17 00:00:00 2001 From: Tristan Le Date: Sun, 24 May 2026 20:35:21 -0400 Subject: [PATCH 9/9] Fraud memory profile report for 100K events --- memory-profile-fraud-team.md | 350 ++++++++++++++++++----------------- 1 file changed, 177 insertions(+), 173 deletions(-) diff --git a/memory-profile-fraud-team.md b/memory-profile-fraud-team.md index 81de6b1a..65d588d3 100644 --- a/memory-profile-fraud-team.md +++ b/memory-profile-fraud-team.md @@ -3,24 +3,24 @@ ## Workload Summary - Workload: `fraud` -- Events requested from generator: `10000` -- Events replayed from generator: `10000` +- Events requested from generator: `100000` +- Events replayed from generator: `100000` - Events by source: - - `Txn`: `10000` + - `Txn`: `100000` - Derivations discovered: `9` - Aggregate features discovered: `111` -- Active entity rows profiled: `13533` -- Bytes per active entity row p99: `25794` bytes +- Active entity rows profiled: `67311` +- Bytes per active entity row p99: `98336` bytes ## Per-Entity Table Footprint | Rank | Table | Source | group_by key | Active entities | Features/entity | Events applied | Stack p50 | Stack p99 | Stack max | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | Top contributor | |------|-------|--------|--------------|-----------------|-----------------|----------------|-----------|-----------|-----------|----------|----------|----------|-----------|-----------|-----------|-----------------| -| 1 | `TxnByIp` | `Txn` | `ip_address` | 1000 | 8 | 10000 | 640 | 640 | 640 | 2992 | 60848 | 61136 | 3632 | 61488 | 61776 | `cards_per_ip_1h` | -| 2 | `TxnByDevice` | `Txn` | `device_id` | 1000 | 6 | 10000 | 480 | 480 | 480 | 1104 | 58192 | 58192 | 1584 | 58672 | 58672 | `cards_per_device_24h` | -| 3 | `TxnByMerchant` | `Txn` | `merchant_id` | 1000 | 4 | 10000 | 320 | 320 | 320 | 3096 | 31640 | 31640 | 3416 | 31960 | 31960 | `users_per_merchant_24h` | -| 4 | `TxnByCard` | `Txn` | `card_fp` | 1000 | 8 | 10000 | 640 | 640 | 640 | 2216 | 30760 | 30760 | 2856 | 31400 | 31400 | `merchants_per_card_24h` | -| 5 | `TxnByUser` | `Txn` | `user_id` | 9533 | 62 | 10000 | 4960 | 4960 | 4960 | 20494 | 20834 | 21434 | 25454 | 25794 | 26394 | `amount_p95_24h` | +| 1 | `TxnByIp` | `Txn` | `ip_address` | 1000 | 8 | 100000 | 640 | 640 | 640 | 98176 | 128448 | 129984 | 98816 | 129088 | 130624 | `cards_per_ip_1h` | +| 2 | `TxnByDevice` | `Txn` | `device_id` | 1000 | 6 | 100000 | 480 | 480 | 480 | 58192 | 58192 | 58192 | 58672 | 58672 | 58672 | `cards_per_device_24h` | +| 3 | `TxnByMerchant` | `Txn` | `merchant_id` | 1000 | 4 | 100000 | 320 | 320 | 320 | 31640 | 31640 | 31640 | 31960 | 31960 | 31960 | `users_per_merchant_24h` | +| 4 | `TxnByCard` | `Txn` | `card_fp` | 1000 | 8 | 100000 | 640 | 640 | 640 | 31080 | 31080 | 31080 | 31720 | 31720 | 31720 | `merchants_per_card_24h` | +| 5 | `TxnByUser` | `Txn` | `user_id` | 63311 | 62 | 100000 | 4960 | 4960 | 4960 | 20494 | 21673 | 23288 | 25454 | 26633 | 28248 | `amount_p95_24h` | | 6 | `CardAddByDevice` | `CardAdd` | `device_id` | 0 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | | 7 | `LoginByUser` | `Login` | `user_id` | 0 | 8 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | | 8 | `RefundByUser` | `Refund` | `user_id` | 0 | 8 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | `-` | @@ -34,11 +34,11 @@ | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `cards_per_ip_1h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | -| `users_per_ip_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | -| `ip_top_users` | `top_k` | `windowed` | 80 | 1376 | 2144 | 2432 | 1456 | 2224 | 2512 | -| `amount_sum_per_ip_1h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_per_ip_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `cards_per_ip_1h` | `n_unique` | `windowed` | 80 | 58008 | 86552 | 86552 | 58088 | 86632 | 86632 | +| `users_per_ip_24h` | `n_unique` | `windowed` | 80 | 28968 | 28968 | 28968 | 29048 | 29048 | 29048 | +| `ip_top_users` | `top_k` | `windowed` | 80 | 10016 | 12128 | 13376 | 10096 | 12208 | 13456 | +| `amount_sum_per_ip_1h` | `sum` | `windowed` | 80 | 416 | 416 | 416 | 496 | 496 | 496 | +| `txn_per_ip_1h` | `count` | `windowed` | 80 | 416 | 416 | 416 | 496 | 496 | 496 | | `txn_per_ip_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `ip_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | | `ip_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | @@ -47,24 +47,24 @@ | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s122` | 21 | 640 | 61136 | 61776 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2512 bytes | -| `s226` | 21 | 640 | 61136 | 61776 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2512 bytes | -| `s870` | 20 | 640 | 61040 | 61680 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2416 bytes | -| `s917` | 20 | 640 | 61040 | 61680 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2416 bytes | -| `s380` | 19 | 640 | 60944 | 61584 | `cards_per_ip_1h`=29048 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=2320 bytes | +| `s533` | 135 | 640 | 129984 | 130624 | `cards_per_ip_1h`=86632 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=13456 bytes | +| `s891` | 127 | 640 | 129216 | 129856 | `cards_per_ip_1h`=86632 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=12688 bytes | +| `s390` | 125 | 640 | 129024 | 129664 | `cards_per_ip_1h`=86632 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=12496 bytes | +| `s58` | 124 | 640 | 128928 | 129568 | `cards_per_ip_1h`=86632 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=12400 bytes | +| `s279` | 122 | 640 | 128640 | 129280 | `cards_per_ip_1h`=86632 bytes, `users_per_ip_24h`=29048 bytes, `ip_top_users`=12112 bytes | -#### Feature Breakdown For Largest Entity `s122` +#### Feature Breakdown For Largest Entity `s533` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `cards_per_ip_1h` | `n_unique` | `windowed` | 21 | 80 | 80 | 8 | 72 | 28968 | 29048 | -| `users_per_ip_24h` | `n_unique` | `windowed` | 21 | 80 | 80 | 8 | 72 | 28968 | 29048 | -| `ip_top_users` | `top_k` | `windowed` | 21 | 80 | 80 | 8 | 72 | 2432 | 2512 | -| `amount_sum_per_ip_1h` | `sum` | `windowed` | 21 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_ip_1h` | `count` | `windowed` | 21 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_ip_24h` | `count` | `windowed` | 21 | 80 | 80 | 8 | 72 | 256 | 336 | -| `ip_age` | `age` | `lifetime` | 21 | 80 | 80 | 32 | 48 | 0 | 80 | -| `ip_first_seen` | `first_seen` | `lifetime` | 21 | 80 | 80 | 32 | 48 | 0 | 80 | +| `cards_per_ip_1h` | `n_unique` | `windowed` | 135 | 80 | 80 | 8 | 72 | 86552 | 86632 | +| `users_per_ip_24h` | `n_unique` | `windowed` | 135 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `ip_top_users` | `top_k` | `windowed` | 135 | 80 | 80 | 8 | 72 | 13376 | 13456 | +| `amount_sum_per_ip_1h` | `sum` | `windowed` | 135 | 80 | 80 | 8 | 72 | 416 | 496 | +| `txn_per_ip_1h` | `count` | `windowed` | 135 | 80 | 80 | 8 | 72 | 416 | 496 | +| `txn_per_ip_24h` | `count` | `windowed` | 135 | 80 | 80 | 8 | 72 | 256 | 336 | +| `ip_age` | `age` | `lifetime` | 135 | 80 | 80 | 32 | 48 | 0 | 80 | +| `ip_first_seen` | `first_seen` | `lifetime` | 135 | 80 | 80 | 32 | 48 | 0 | 80 | ### `TxnByDevice` (`Txn` by `device_id`) @@ -72,8 +72,8 @@ | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `cards_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | -| `users_per_device_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `cards_per_device_24h` | `n_unique` | `windowed` | 80 | 28968 | 28968 | 28968 | 29048 | 29048 | 29048 | +| `users_per_device_24h` | `n_unique` | `windowed` | 80 | 28968 | 28968 | 28968 | 29048 | 29048 | 29048 | | `device_txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `device_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | | `device_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | @@ -83,22 +83,22 @@ | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s960` | 24 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | -| `s186` | 22 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | -| `s741` | 22 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | -| `s549` | 21 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | -| `s939` | 21 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s885` | 134 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s632` | 128 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s641` | 128 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s966` | 128 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | +| `s605` | 127 | 480 | 58192 | 58672 | `cards_per_device_24h`=29048 bytes, `users_per_device_24h`=29048 bytes, `device_txn_count_24h`=336 bytes | -#### Feature Breakdown For Largest Entity `s960` +#### Feature Breakdown For Largest Entity `s885` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `cards_per_device_24h` | `n_unique` | `windowed` | 24 | 80 | 80 | 8 | 72 | 28968 | 29048 | -| `users_per_device_24h` | `n_unique` | `windowed` | 24 | 80 | 80 | 8 | 72 | 28968 | 29048 | -| `device_txn_count_24h` | `count` | `windowed` | 24 | 80 | 80 | 8 | 72 | 256 | 336 | -| `device_age` | `age` | `lifetime` | 24 | 80 | 80 | 32 | 48 | 0 | 80 | -| `device_first_seen` | `first_seen` | `lifetime` | 24 | 80 | 80 | 32 | 48 | 0 | 80 | -| `device_last_seen` | `last_seen` | `lifetime` | 24 | 80 | 80 | 32 | 48 | 0 | 80 | +| `cards_per_device_24h` | `n_unique` | `windowed` | 134 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `users_per_device_24h` | `n_unique` | `windowed` | 134 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `device_txn_count_24h` | `count` | `windowed` | 134 | 80 | 80 | 8 | 72 | 256 | 336 | +| `device_age` | `age` | `lifetime` | 134 | 80 | 80 | 32 | 48 | 0 | 80 | +| `device_first_seen` | `first_seen` | `lifetime` | 134 | 80 | 80 | 32 | 48 | 0 | 80 | +| `device_last_seen` | `last_seen` | `lifetime` | 134 | 80 | 80 | 32 | 48 | 0 | 80 | ### `TxnByMerchant` (`Txn` by `merchant_id`) @@ -106,7 +106,7 @@ | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `users_per_merchant_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `users_per_merchant_24h` | `n_unique` | `windowed` | 80 | 28968 | 28968 | 28968 | 29048 | 29048 | 29048 | | `merchant_amount_p99_24h` | `quantile` | `windowed` | 80 | 2416 | 2416 | 2416 | 2496 | 2496 | 2496 | | `txn_per_merchant_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `merchant_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | @@ -115,20 +115,20 @@ | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s201` | 23 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | -| `s370` | 21 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | -| `s494` | 21 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | -| `s570` | 21 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | -| `s591` | 20 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s969` | 135 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s428` | 132 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s676` | 132 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s725` | 129 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | +| `s806` | 129 | 320 | 31640 | 31960 | `users_per_merchant_24h`=29048 bytes, `merchant_amount_p99_24h`=2496 bytes, `txn_per_merchant_24h`=336 bytes | -#### Feature Breakdown For Largest Entity `s201` +#### Feature Breakdown For Largest Entity `s969` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `users_per_merchant_24h` | `n_unique` | `windowed` | 23 | 80 | 80 | 8 | 72 | 28968 | 29048 | -| `merchant_amount_p99_24h` | `quantile` | `windowed` | 23 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `txn_per_merchant_24h` | `count` | `windowed` | 23 | 80 | 80 | 8 | 72 | 256 | 336 | -| `merchant_first_seen` | `first_seen` | `lifetime` | 23 | 80 | 80 | 32 | 48 | 0 | 80 | +| `users_per_merchant_24h` | `n_unique` | `windowed` | 135 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `merchant_amount_p99_24h` | `quantile` | `windowed` | 135 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `txn_per_merchant_24h` | `count` | `windowed` | 135 | 80 | 80 | 8 | 72 | 256 | 336 | +| `merchant_first_seen` | `first_seen` | `lifetime` | 135 | 80 | 80 | 32 | 48 | 0 | 80 | ### `TxnByCard` (`Txn` by `card_fp`) @@ -136,10 +136,10 @@ | Feature | Op | Shape | Stack bytes | Heap p50 | Heap p99 | Heap max | Total p50 | Total p99 | Total max | |---------|----|-------|-------------|----------|----------|----------|-----------|-----------|-----------| -| `merchants_per_card_24h` | `n_unique` | `windowed` | 80 | 424 | 28968 | 28968 | 504 | 29048 | 29048 | +| `merchants_per_card_24h` | `n_unique` | `windowed` | 80 | 28968 | 28968 | 28968 | 29048 | 29048 | 29048 | | `small_amt_burst_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | -| `decline_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_per_card_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | +| `decline_count_1h` | `count` | `windowed` | 80 | 416 | 416 | 416 | 496 | 496 | 496 | +| `txn_per_card_1h` | `count` | `windowed` | 80 | 416 | 416 | 416 | 496 | 496 | 496 | | `txn_per_card_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `card_age` | `age` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | | `card_first_seen` | `first_seen` | `lifetime` | 80 | 0 | 0 | 0 | 80 | 80 | 80 | @@ -149,24 +149,24 @@ | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `s774` | 26 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | -| `s395` | 23 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | -| `s546` | 23 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | -| `s896` | 23 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | -| `s505` | 21 | 640 | 30760 | 31400 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=336 bytes | +| `s180` | 130 | 640 | 31080 | 31720 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=496 bytes | +| `s560` | 130 | 640 | 31080 | 31720 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=496 bytes | +| `s272` | 129 | 640 | 31080 | 31720 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=496 bytes | +| `s362` | 129 | 640 | 31080 | 31720 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=496 bytes | +| `s42` | 129 | 640 | 31080 | 31720 | `merchants_per_card_24h`=29048 bytes, `small_amt_burst_5m`=1104 bytes, `decline_count_1h`=496 bytes | -#### Feature Breakdown For Largest Entity `s774` +#### Feature Breakdown For Largest Entity `s180` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `merchants_per_card_24h` | `n_unique` | `windowed` | 26 | 80 | 80 | 8 | 72 | 28968 | 29048 | -| `small_amt_burst_5m` | `burst_count` | `windowed` | 26 | 80 | 80 | 72 | 8 | 1024 | 1104 | -| `decline_count_1h` | `count` | `windowed` | 26 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_card_1h` | `count` | `windowed` | 26 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_per_card_24h` | `count` | `windowed` | 26 | 80 | 80 | 8 | 72 | 256 | 336 | -| `card_age` | `age` | `lifetime` | 26 | 80 | 80 | 32 | 48 | 0 | 80 | -| `card_first_seen` | `first_seen` | `lifetime` | 26 | 80 | 80 | 32 | 48 | 0 | 80 | -| `decline_streak_card` | `negative_streak` | `lifetime` | 26 | 80 | 80 | 8 | 72 | 0 | 80 | +| `merchants_per_card_24h` | `n_unique` | `windowed` | 130 | 80 | 80 | 8 | 72 | 28968 | 29048 | +| `small_amt_burst_5m` | `burst_count` | `windowed` | 130 | 80 | 80 | 72 | 8 | 1024 | 1104 | +| `decline_count_1h` | `count` | `windowed` | 130 | 80 | 80 | 8 | 72 | 416 | 496 | +| `txn_per_card_1h` | `count` | `windowed` | 130 | 80 | 80 | 8 | 72 | 416 | 496 | +| `txn_per_card_24h` | `count` | `windowed` | 130 | 80 | 80 | 8 | 72 | 256 | 336 | +| `card_age` | `age` | `lifetime` | 130 | 80 | 80 | 32 | 48 | 0 | 80 | +| `card_first_seen` | `first_seen` | `lifetime` | 130 | 80 | 80 | 32 | 48 | 0 | 80 | +| `decline_streak_card` | `negative_streak` | `lifetime` | 130 | 80 | 80 | 8 | 72 | 0 | 80 | ### `TxnByUser` (`Txn` by `user_id`) @@ -182,26 +182,26 @@ | `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 80 | 1344 | 1344 | 1344 | 1424 | 1424 | 1424 | | `device_seen` | `bloom_member` | `lifetime` | 80 | 1280 | 1280 | 1280 | 1360 | 1360 | 1360 | | `burst_count_5m` | `burst_count` | `windowed` | 80 | 1024 | 1024 | 1024 | 1104 | 1104 | 1104 | -| `top_merchants_24h` | `top_k` | `windowed` | 80 | 512 | 608 | 800 | 592 | 688 | 880 | +| `top_merchants_24h` | `top_k` | `windowed` | 80 | 512 | 800 | 1184 | 592 | 880 | 1264 | +| `mcc_entropy_24h` | `entropy` | `windowed` | 80 | 396 | 648 | 984 | 476 | 728 | 1064 | | `seasonal_dev` | `seasonal_deviation` | `lifetime` | 80 | 600 | 600 | 600 | 680 | 680 | 680 | -| `mcc_entropy_24h` | `entropy` | `windowed` | 80 | 396 | 480 | 648 | 476 | 560 | 728 | +| `txn_count_5m` | `count` | `windowed` | 80 | 256 | 496 | 944 | 336 | 576 | 1024 | +| `event_mix_24h` | `event_type_mix` | `lifetime` | 80 | 208 | 448 | 768 | 288 | 528 | 848 | | `countries_distinct_7d` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | | `ips_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | | `merchants_distinct_24h` | `n_unique` | `windowed` | 80 | 424 | 424 | 424 | 504 | 504 | 504 | -| `txn_count_5m` | `count` | `windowed` | 80 | 256 | 336 | 416 | 336 | 416 | 496 | -| `event_mix_24h` | `event_type_mix` | `lifetime` | 80 | 208 | 288 | 448 | 288 | 368 | 528 | +| `txn_count_1h` | `count` | `windowed` | 80 | 256 | 416 | 416 | 336 | 496 | 496 | | `avg_amount_24h` | `mean` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `min_amount_24h` | `min` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `std_amount_24h` | `std` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `sum_amount_24h` | `sum` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | -| `txn_count_1h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `txn_count_24h` | `count` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `var_amount_24h` | `var` | `windowed` | 80 | 256 | 256 | 256 | 336 | 336 | 336 | | `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 80 | 192 | 192 | 192 | 272 | 272 | 272 | | `unique_cells_24h` | `n_unique` | `lifetime` | 80 | 168 | 168 | 168 | 248 | 248 | 248 | | `last_5_amounts` | `last_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | | `recent_5_amts` | `most_recent_n` | `lifetime` | 80 | 160 | 160 | 160 | 240 | 240 | 240 | -| `first_5_merchants` | `first_n` | `lifetime` | 80 | 128 | 128 | 128 | 208 | 208 | 208 | +| `first_5_merchants` | `first_n` | `lifetime` | 80 | 128 | 128 | 256 | 208 | 208 | 336 | | `geo_kmh` | `geo_velocity` | `lifetime` | 80 | 94 | 94 | 94 | 174 | 174 | 174 | | `geo_spread_24h` | `geo_spread` | `lifetime` | 80 | 94 | 94 | 94 | 174 | 174 | 174 | | `geo_dist_last` | `geo_distance` | `lifetime` | 80 | 86 | 86 | 86 | 166 | 166 | 166 | @@ -241,78 +241,78 @@ | Entity key | Events | Stack bytes | Heap bytes | Total bytes | Top feature contributors | |------------|--------|-------------|------------|-------------|--------------------------| -| `k00032049` | 4 | 4960 | 21434 | 26394 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00045411` | 3 | 4960 | 21174 | 26134 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00011780` | 3 | 4960 | 21094 | 26054 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00017976` | 3 | 4960 | 21094 | 26054 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -| `k00035736` | 3 | 4960 | 21094 | 26054 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00021309` | 8 | 4960 | 23288 | 28248 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00074547` | 8 | 4960 | 23288 | 28248 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00088034` | 8 | 4960 | 23130 | 28090 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00089103` | 8 | 4960 | 23129 | 28089 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | +| `k00013686` | 7 | 4960 | 22950 | 27910 | `amount_p95_24h`=2496 bytes, `p50_amount_24h`=2496 bytes, `p99_amount_24h`=2496 bytes | -#### Feature Breakdown For Largest Entity `k00032049` +#### Feature Breakdown For Largest Entity `k00021309` | Feature | Op | Shape | Events applied | Stack bytes | enum_slot_bytes | payload_bytes | slack_bytes | Heap bytes | Total bytes | |---------|----|-------|----------------|-------------|-----------------|---------------|-------------|------------|-------------| -| `amount_p95_24h` | `quantile` | `windowed` | 4 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `p50_amount_24h` | `quantile` | `windowed` | 4 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `p99_amount_24h` | `quantile` | `windowed` | 4 | 80 | 80 | 8 | 72 | 2416 | 2496 | -| `dist_from_home` | `distance_from_home` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 1720 | 1800 | -| `reservoir_50` | `reservoir_sample` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 1600 | 1680 | -| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 4 | 80 | 80 | 24 | 56 | 1344 | 1424 | -| `device_seen` | `bloom_member` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 1280 | 1360 | -| `burst_count_5m` | `burst_count` | `windowed` | 4 | 80 | 80 | 72 | 8 | 1024 | 1104 | -| `top_merchants_24h` | `top_k` | `windowed` | 4 | 80 | 80 | 8 | 72 | 800 | 880 | -| `mcc_entropy_24h` | `entropy` | `windowed` | 4 | 80 | 80 | 8 | 72 | 648 | 728 | -| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 600 | 680 | -| `event_mix_24h` | `event_type_mix` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 448 | 528 | -| `countries_distinct_7d` | `n_unique` | `windowed` | 4 | 80 | 80 | 8 | 72 | 424 | 504 | -| `ips_distinct_24h` | `n_unique` | `windowed` | 4 | 80 | 80 | 8 | 72 | 424 | 504 | -| `merchants_distinct_24h` | `n_unique` | `windowed` | 4 | 80 | 80 | 8 | 72 | 424 | 504 | -| `txn_count_5m` | `count` | `windowed` | 4 | 80 | 80 | 8 | 72 | 416 | 496 | -| `avg_amount_24h` | `mean` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `min_amount_24h` | `min` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `std_amount_24h` | `std` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `sum_amount_24h` | `sum` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_count_1h` | `count` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `txn_count_24h` | `count` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `var_amount_24h` | `var` | `windowed` | 4 | 80 | 80 | 8 | 72 | 256 | 336 | -| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 192 | 272 | -| `unique_cells_24h` | `n_unique` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 168 | 248 | -| `last_5_amounts` | `last_n` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 160 | 240 | -| `recent_5_amts` | `most_recent_n` | `lifetime` | 4 | 80 | 80 | 48 | 32 | 160 | 240 | -| `first_5_merchants` | `first_n` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 128 | 208 | -| `geo_kmh` | `geo_velocity` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 94 | 174 | -| `geo_spread_24h` | `geo_spread` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 94 | 174 | -| `geo_dist_last` | `geo_distance` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 86 | 166 | -| `amount_lag1` | `lag` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 64 | 144 | -| `geo_entropy_24h` | `entropy` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 56 | 136 | -| `time_since_last_5` | `time_since_last_n` | `lifetime` | 4 | 80 | 80 | 40 | 40 | 40 | 120 | -| `age` | `age` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_delta` | `delta_from_prev` | `lifetime` | 4 | 80 | 80 | 24 | 56 | 0 | 80 | -| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 4 | 80 | 80 | 48 | 32 | 0 | 80 | -| `amount_ewma_1h` | `ewma` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_ewvar_1h` | `ewvar` | `lifetime` | 4 | 80 | 80 | 48 | 32 | 0 | 80 | -| `amount_outliers_5m` | `outlier_count` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | -| `amount_rate_5m` | `rate_of_change` | `windowed` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `amount_trend_5m` | `trend` | `windowed` | 4 | 80 | 80 | 48 | 32 | 0 | 80 | -| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 4 | 80 | 80 | 72 | 8 | 0 | 80 | -| `amount_twa_5m` | `twa` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | -| `amount_z_score` | `z_score` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | -| `decline_streak` | `negative_streak` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 0 | 80 | -| `device_change_count_5m` | `value_change_count` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | -| `first_amount` | `first` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `first_in_24h` | `first_seen_in_window` | `windowed` | 4 | 80 | 80 | 24 | 56 | 0 | 80 | -| `first_seen` | `first_seen` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `has_seen` | `has_seen` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 4 | 80 | 80 | 40 | 40 | 0 | 80 | -| `last_amount` | `last` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `last_seen` | `last_seen` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `max_amount_lifetime` | `max` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `max_streak` | `max_streak` | `lifetime` | 4 | 80 | 80 | 16 | 64 | 0 | 80 | -| `sum_amount_lifetime` | `sum` | `lifetime` | 4 | 80 | 80 | 16 | 64 | 0 | 80 | -| `time_since_last` | `time_since` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `txn_count_lifetime` | `count` | `lifetime` | 4 | 80 | 80 | 8 | 72 | 0 | 80 | -| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 4 | 80 | 80 | 32 | 48 | 0 | 80 | -| `txn_streak` | `streak` | `lifetime` | 4 | 80 | 80 | 16 | 64 | 0 | 80 | +| `amount_p95_24h` | `quantile` | `windowed` | 8 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `p50_amount_24h` | `quantile` | `windowed` | 8 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `p99_amount_24h` | `quantile` | `windowed` | 8 | 80 | 80 | 8 | 72 | 2416 | 2496 | +| `dist_from_home` | `distance_from_home` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 1720 | 1800 | +| `reservoir_50` | `reservoir_sample` | `lifetime` | 8 | 80 | 80 | 40 | 40 | 1600 | 1680 | +| `dow_hour_hist_30d` | `dow_hour_histogram` | `lifetime` | 8 | 80 | 80 | 24 | 56 | 1344 | 1424 | +| `device_seen` | `bloom_member` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 1280 | 1360 | +| `top_merchants_24h` | `top_k` | `windowed` | 8 | 80 | 80 | 8 | 72 | 1184 | 1264 | +| `burst_count_5m` | `burst_count` | `windowed` | 8 | 80 | 80 | 72 | 8 | 1024 | 1104 | +| `mcc_entropy_24h` | `entropy` | `windowed` | 8 | 80 | 80 | 8 | 72 | 982 | 1062 | +| `txn_count_5m` | `count` | `windowed` | 8 | 80 | 80 | 8 | 72 | 944 | 1024 | +| `event_mix_24h` | `event_type_mix` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 768 | 848 | +| `seasonal_dev` | `seasonal_deviation` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 600 | 680 | +| `countries_distinct_7d` | `n_unique` | `windowed` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | +| `ips_distinct_24h` | `n_unique` | `windowed` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | +| `merchants_distinct_24h` | `n_unique` | `windowed` | 8 | 80 | 80 | 8 | 72 | 424 | 504 | +| `txn_count_1h` | `count` | `windowed` | 8 | 80 | 80 | 8 | 72 | 416 | 496 | +| `avg_amount_24h` | `mean` | `windowed` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | +| `first_5_merchants` | `first_n` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 256 | 336 | +| `min_amount_24h` | `min` | `windowed` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | +| `std_amount_24h` | `std` | `windowed` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | +| `sum_amount_24h` | `sum` | `windowed` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | +| `txn_count_24h` | `count` | `windowed` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | +| `var_amount_24h` | `var` | `windowed` | 8 | 80 | 80 | 8 | 72 | 256 | 336 | +| `hour_hist_30d` | `hour_of_day_histogram` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 192 | 272 | +| `unique_cells_24h` | `n_unique` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 168 | 248 | +| `last_5_amounts` | `last_n` | `lifetime` | 8 | 80 | 80 | 40 | 40 | 160 | 240 | +| `recent_5_amts` | `most_recent_n` | `lifetime` | 8 | 80 | 80 | 48 | 32 | 160 | 240 | +| `geo_kmh` | `geo_velocity` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 94 | 174 | +| `geo_spread_24h` | `geo_spread` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 94 | 174 | +| `geo_dist_last` | `geo_distance` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 86 | 166 | +| `amount_lag1` | `lag` | `lifetime` | 8 | 80 | 80 | 40 | 40 | 64 | 144 | +| `geo_entropy_24h` | `entropy` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 56 | 136 | +| `time_since_last_5` | `time_since_last_n` | `lifetime` | 8 | 80 | 80 | 40 | 40 | 40 | 120 | +| `age` | `age` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_decayed_sum_24h` | `decayed_sum` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_delta` | `delta_from_prev` | `lifetime` | 8 | 80 | 80 | 24 | 56 | 0 | 80 | +| `amount_ew_zscore` | `ew_zscore` | `lifetime` | 8 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_ewma_1h` | `ewma` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_ewvar_1h` | `ewvar` | `lifetime` | 8 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_outliers_5m` | `outlier_count` | `windowed` | 8 | 80 | 80 | 40 | 40 | 0 | 80 | +| `amount_rate_5m` | `rate_of_change` | `windowed` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `amount_trend_5m` | `trend` | `windowed` | 8 | 80 | 80 | 48 | 32 | 0 | 80 | +| `amount_trend_resid_5m` | `trend_residual` | `windowed` | 8 | 80 | 80 | 72 | 8 | 0 | 80 | +| `amount_twa_5m` | `twa` | `windowed` | 8 | 80 | 80 | 40 | 40 | 0 | 80 | +| `amount_z_score` | `z_score` | `windowed` | 8 | 80 | 80 | 40 | 40 | 0 | 80 | +| `decline_streak` | `negative_streak` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 0 | 80 | +| `device_change_count_5m` | `value_change_count` | `windowed` | 8 | 80 | 80 | 40 | 40 | 0 | 80 | +| `first_amount` | `first` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `first_in_24h` | `first_seen_in_window` | `windowed` | 8 | 80 | 80 | 24 | 56 | 0 | 80 | +| `first_seen` | `first_seen` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `has_seen` | `has_seen` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `inter_arrival_1h` | `inter_arrival_stats` | `windowed` | 8 | 80 | 80 | 40 | 40 | 0 | 80 | +| `last_amount` | `last` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `last_seen` | `last_seen` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `max_amount_lifetime` | `max` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `max_streak` | `max_streak` | `lifetime` | 8 | 80 | 80 | 16 | 64 | 0 | 80 | +| `sum_amount_lifetime` | `sum` | `lifetime` | 8 | 80 | 80 | 16 | 64 | 0 | 80 | +| `time_since_last` | `time_since` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `txn_count_lifetime` | `count` | `lifetime` | 8 | 80 | 80 | 8 | 72 | 0 | 80 | +| `txn_decayed_count_24h` | `decayed_count` | `lifetime` | 8 | 80 | 80 | 32 | 48 | 0 | 80 | +| `txn_streak` | `streak` | `lifetime` | 8 | 80 | 80 | 16 | 64 | 0 | 80 | ### `CardAddByDevice` (`CardAdd` by `device_id`) @@ -334,42 +334,46 @@ No active entity rows. Configured features: `4`. The workload generator emitted One heaviest entity-feature example per unique op. -### 1. `Txn` / `TxnByCard` / `merchants_per_card_24h` / `n_unique` +### 1. `Txn` / `TxnByIp` / `cards_per_ip_1h` / `n_unique` -- Path: `Txn` -> `TxnByCard` -> `merchants_per_card_24h` -> `n_unique` -> `windowed` -- Entity key: `s774` -- Entity events: `26` -- Key path: `card_fp` -- Events applied: `26` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=28968 total=29048 -- Shape: `windowed` (1d) +- Path: `Txn` -> `TxnByIp` -> `cards_per_ip_1h` -> `n_unique` -> `windowed` +- Entity key: `s533` +- Entity events: `135` +- Key path: `ip_address` +- Events applied: `135` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=86552 total=86632 +- Shape: `windowed` (1h) - Breakdown rollup: - - `CountDistinct hash-set slots across buckets`: 28672 bytes (HashSet, summed across active window buckets) + - `CountDistinct hash-set slots across buckets`: 86016 bytes (HashSet, summed across active window buckets) + - `Windowed bucket shell overhead`: 240 bytes (Box, summed boxed AggOp enum slots across active buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - - `Box across buckets`: 40 bytes (Box, summed across active window buckets) + - `Box across buckets`: 120 bytes (Box, summed across active window buckets) - Raw breakdown: - `Windowed bucket 0 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 1 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) + - `Windowed bucket 2 / CountDistinct hash-set slots`: 28672 bytes (HashSet, estimated hashbrown slot cost for u64 distinct hashes) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 1 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) + - `Windowed bucket 2 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) - `Windowed bucket 0 / Box`: 40 bytes (Box, heap allocation for boxed CountDistinct wrapper) ### 2. `Txn` / `TxnByIp` / `ip_top_users` / `top_k` - Path: `Txn` -> `TxnByIp` -> `ip_top_users` -> `top_k` -> `windowed` -- Entity key: `s122` -- Entity events: `21` +- Entity key: `s533` +- Entity events: `135` - Key path: `ip_address` -- Events applied: `21` -- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2432 total=2512 +- Events applied: `135` +- Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=13376 total=13456 - Shape: `windowed` (1d) - Breakdown rollup: - - `TopK exact BTreeMap entries across buckets`: 2016 bytes (BTreeMap, summed across active window buckets) + - `TopK exact BTreeMap entries across buckets`: 12960 bytes (BTreeMap, summed across active window buckets) - `Windowed wrapper overhead`: 176 bytes (WindowedOp, summed boxed WindowedOp payload and spilled bucket storage) - `Box across buckets`: 160 bytes (Box, summed across active window buckets) - `Windowed bucket shell overhead`: 80 bytes (Box, summed boxed AggOp enum slots across active buckets) - Raw breakdown: - - `Windowed bucket 0 / TopK exact BTreeMap entries`: 2016 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) + - `Windowed bucket 0 / TopK exact BTreeMap entries`: 12960 bytes (BTreeMap, estimated node overhead plus TopKValue/u64 payloads) - `Box`: 176 bytes (Box, heap allocation for boxed WindowedOp payload) - `Windowed bucket 0 / Box`: 160 bytes (Box, heap allocation for boxed TopK wrapper) - `Windowed bucket 0 Box`: 80 bytes (Box, heap allocation for bucket AggOp enum slot) @@ -377,10 +381,10 @@ One heaviest entity-feature example per unique op. ### 3. `Txn` / `TxnByMerchant` / `merchant_amount_p99_24h` / `quantile` - Path: `Txn` -> `TxnByMerchant` -> `merchant_amount_p99_24h` -> `quantile` -> `windowed` -- Entity key: `s201` -- Entity events: `23` +- Entity key: `s969` +- Entity events: `135` - Key path: `merchant_id` -- Events applied: `23` +- Events applied: `135` - Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=2416 total=2496 - Shape: `windowed` (1d) - Breakdown rollup: @@ -397,10 +401,10 @@ One heaviest entity-feature example per unique op. ### 4. `Txn` / `TxnByUser` / `dist_from_home` / `distance_from_home` - Path: `Txn` -> `TxnByUser` -> `dist_from_home` -> `distance_from_home` -> `lifetime` -- Entity key: `k00032049` -- Entity events: `4` +- Entity key: `k00021309` +- Entity events: `8` - Key path: `user_id` -- Events applied: `4` +- Events applied: `8` - Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=8 slack_bytes=72) heap=1720 total=1800 - Shape: `lifetime` - Breakdown: @@ -410,10 +414,10 @@ One heaviest entity-feature example per unique op. ### 5. `Txn` / `TxnByUser` / `reservoir_50` / `reservoir_sample` - Path: `Txn` -> `TxnByUser` -> `reservoir_50` -> `reservoir_sample` -> `lifetime` -- Entity key: `k00032049` -- Entity events: `4` +- Entity key: `k00021309` +- Entity events: `8` - Key path: `user_id` -- Events applied: `4` +- Events applied: `8` - Bytes: stack=80 (enum_slot_bytes=80 payload_bytes=40 slack_bytes=40) heap=1600 total=1680 - Shape: `lifetime` - Breakdown: @@ -422,9 +426,9 @@ One heaviest entity-feature example per unique op. ## Metrics Coherence - `/metrics` `beava_bytes_per_entity_p99`: `7000` bytes -- Profile bytes-per-active-entity-row p99: `25794` bytes +- Profile bytes-per-active-entity-row p99: `98336` bytes - Tolerance: `15.0%` -- Assertion: bytes_per_entity_p99 diverged by 18794 bytes; file sibling work to replace the static placeholder with live sampling. +- Assertion: bytes_per_entity_p99 diverged by 91336 bytes; file sibling work to replace the static placeholder with live sampling. ## Notes