mirror of
https://github.com/rojo-rbx/rojo.git
synced 2026-10-23 14:01:37 +00:00
Add statistics tracking for syncback operations
- Introduced a new `SyncbackStats` module to track and report issues during syncback, including duplicate names, unknown classes, and properties. - Updated the `syncback_loop` and related functions to utilize the stats tracker, logging summaries of issues encountered. - Enhanced property filtering and instance syncing to record statistics on unknown classes and properties. - Modified tests to ensure consistent output by normalizing temporary paths in snapshots. - Added `regex` dependency for path normalization in tests.
This commit is contained in:
Joe
parent
58399bb863
commit
8fe908740f
14 changed files with 541 additions and 84 deletions
334
src/syncback/stats.rs
Normal file
334
src/syncback/stats.rs
Normal file
|
|
@ -0,0 +1,334 @@
|
|||
//! Statistics tracking for syncback operations.
|
||||
//!
|
||||
//! This module provides a way to track and report various issues that occur
|
||||
//! during syncback, including:
|
||||
//! - Instances with duplicate names (indistinguishable paths)
|
||||
//! - Instances that fell back to rbxm/rbxmx format
|
||||
//! - Unknown classes not in the reflection database
|
||||
//! - Unknown properties not in the reflection database
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::Mutex;
|
||||
|
||||
/// Statistics collected during a syncback operation.
|
||||
///
|
||||
/// This struct is designed to be used in a single-threaded context during
|
||||
/// the main syncback loop, but uses interior mutability for flexibility.
|
||||
#[derive(Default)]
|
||||
pub struct SyncbackStats {
|
||||
/// Count of instances skipped due to duplicate/indistinguishable names.
|
||||
duplicate_name_count: AtomicUsize,
|
||||
/// Count of instances that fell back to rbxm/rbxmx format.
|
||||
rbxm_fallback_count: AtomicUsize,
|
||||
/// Count of instances with unknown classes.
|
||||
unknown_class_count: AtomicUsize,
|
||||
/// Count of properties with unknown definitions.
|
||||
unknown_property_count: AtomicUsize,
|
||||
|
||||
/// Set of unknown class names encountered (for reporting).
|
||||
unknown_classes: Mutex<HashSet<String>>,
|
||||
/// Set of unknown property names encountered (class.property format).
|
||||
unknown_properties: Mutex<HashSet<String>>,
|
||||
}
|
||||
|
||||
impl SyncbackStats {
|
||||
/// Creates a new empty stats tracker.
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
|
||||
/// Records that an instance was skipped due to having a duplicate name.
|
||||
///
|
||||
/// When debug logging is enabled, logs the individual instance path.
|
||||
pub fn record_duplicate_name(&self, inst_path: &str, name: &str) {
|
||||
self.duplicate_name_count.fetch_add(1, Ordering::Relaxed);
|
||||
|
||||
// Only log individual instances at debug level to avoid spam
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
log::debug!(
|
||||
"Skipping instance due to duplicate name: '{}' at '{}'",
|
||||
name,
|
||||
inst_path
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Records that multiple instances were skipped due to duplicate names at a path.
|
||||
///
|
||||
/// This is more efficient when multiple duplicates are detected at once.
|
||||
pub fn record_duplicate_names_batch(
|
||||
&self,
|
||||
inst_path: &str,
|
||||
duplicate_names: &[&str],
|
||||
total_skipped: usize,
|
||||
) {
|
||||
self.duplicate_name_count
|
||||
.fetch_add(total_skipped, Ordering::Relaxed);
|
||||
|
||||
// Only log at debug level
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
log::debug!(
|
||||
"Skipping {} instance(s) with duplicate names at '{}': {:?}",
|
||||
total_skipped,
|
||||
inst_path,
|
||||
duplicate_names
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Records that an instance fell back to rbxm/rbxmx format.
|
||||
pub fn record_rbxm_fallback(&self, inst_path: &str, reason: &str) {
|
||||
self.rbxm_fallback_count.fetch_add(1, Ordering::Relaxed);
|
||||
|
||||
// Only log individual fallbacks at debug level
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
log::debug!(
|
||||
"Instance '{}' fell back to binary model format: {}",
|
||||
inst_path,
|
||||
reason
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Records that an unknown class was encountered.
|
||||
pub fn record_unknown_class(&self, class_name: &str) {
|
||||
self.unknown_class_count.fetch_add(1, Ordering::Relaxed);
|
||||
|
||||
if let Ok(mut classes) = self.unknown_classes.lock() {
|
||||
if classes.insert(class_name.to_string()) {
|
||||
// Only log when we see a new unknown class
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
log::debug!(
|
||||
"Encountered unknown class not in reflection database: '{}'",
|
||||
class_name
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Records that an unknown property was encountered.
|
||||
pub fn record_unknown_property(&self, class_name: &str, property_name: &str) {
|
||||
self.unknown_property_count.fetch_add(1, Ordering::Relaxed);
|
||||
|
||||
let key = format!("{}.{}", class_name, property_name);
|
||||
if let Ok(mut properties) = self.unknown_properties.lock() {
|
||||
if properties.insert(key.clone()) {
|
||||
// Only log when we see a new unknown property
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
log::debug!(
|
||||
"Encountered unknown property not in reflection database: '{}'",
|
||||
key
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the count of instances skipped due to duplicate names.
|
||||
pub fn duplicate_name_count(&self) -> usize {
|
||||
self.duplicate_name_count.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// Returns the count of instances that fell back to rbxm format.
|
||||
pub fn rbxm_fallback_count(&self) -> usize {
|
||||
self.rbxm_fallback_count.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// Returns the count of unknown classes encountered.
|
||||
pub fn unknown_class_count(&self) -> usize {
|
||||
self.unknown_class_count.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// Returns the count of unknown properties encountered.
|
||||
pub fn unknown_property_count(&self) -> usize {
|
||||
self.unknown_property_count.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// Returns the unique unknown class names.
|
||||
pub fn unknown_classes(&self) -> Vec<String> {
|
||||
self.unknown_classes
|
||||
.lock()
|
||||
.map(|g| g.iter().cloned().collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Returns the unique unknown properties (as "Class.Property").
|
||||
pub fn unknown_properties(&self) -> Vec<String> {
|
||||
self.unknown_properties
|
||||
.lock()
|
||||
.map(|g| g.iter().cloned().collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Returns true if any issues were recorded.
|
||||
pub fn has_issues(&self) -> bool {
|
||||
self.duplicate_name_count() > 0
|
||||
|| self.rbxm_fallback_count() > 0
|
||||
|| self.unknown_class_count() > 0
|
||||
|| self.unknown_property_count() > 0
|
||||
}
|
||||
|
||||
/// Returns true if there are unknown classes or properties that should be
|
||||
/// reported for reflection database updates.
|
||||
pub fn has_unknown_types(&self) -> bool {
|
||||
self.unknown_class_count() > 0 || self.unknown_property_count() > 0
|
||||
}
|
||||
|
||||
/// Logs a summary of all recorded issues as warnings.
|
||||
///
|
||||
/// This should be called at the end of a syncback operation.
|
||||
pub fn log_summary(&self) {
|
||||
let duplicate_count = self.duplicate_name_count();
|
||||
let rbxm_count = self.rbxm_fallback_count();
|
||||
let unknown_class_count = self.unknown_class_count();
|
||||
let unknown_prop_count = self.unknown_property_count();
|
||||
|
||||
if !self.has_issues() {
|
||||
return;
|
||||
}
|
||||
|
||||
log::warn!("Syncback completed with issues:");
|
||||
|
||||
if duplicate_count > 0 {
|
||||
log::warn!(
|
||||
" - {} instance(s) could not be synced due to duplicate/indistinguishable names",
|
||||
duplicate_count
|
||||
);
|
||||
}
|
||||
|
||||
if rbxm_count > 0 {
|
||||
log::warn!(
|
||||
" - {} instance(s) fell back to binary model format (rbxm/rbxmx)",
|
||||
rbxm_count
|
||||
);
|
||||
}
|
||||
|
||||
if unknown_class_count > 0 {
|
||||
let classes = self.unknown_classes();
|
||||
log::warn!(
|
||||
" - {} instance(s) have unknown classes not in reflection database",
|
||||
unknown_class_count
|
||||
);
|
||||
if log::log_enabled!(log::Level::Info) && !classes.is_empty() {
|
||||
log::info!(" Unknown classes: {:?}", classes);
|
||||
}
|
||||
}
|
||||
|
||||
if unknown_prop_count > 0 {
|
||||
let properties = self.unknown_properties();
|
||||
log::warn!(
|
||||
" - {} property reference(s) to unknown properties not in reflection database",
|
||||
unknown_prop_count
|
||||
);
|
||||
if log::log_enabled!(log::Level::Info) && !properties.is_empty() {
|
||||
// Only show first 20 to avoid spam
|
||||
let display: Vec<_> = properties.iter().take(20).collect();
|
||||
let remaining = properties.len().saturating_sub(20);
|
||||
if remaining > 0 {
|
||||
log::info!(
|
||||
" Unknown properties (showing 20 of {}): {:?}",
|
||||
properties.len(),
|
||||
display
|
||||
);
|
||||
} else {
|
||||
log::info!(" Unknown properties: {:?}", display);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Helpful hint about debug logging
|
||||
if duplicate_count > 0 || rbxm_count > 0 {
|
||||
log::info!(
|
||||
" Enable debug logging (RUST_LOG=debug) to see individual instance details"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Merges stats from another SyncbackStats instance into this one.
|
||||
pub fn merge(&self, other: &SyncbackStats) {
|
||||
self.duplicate_name_count.fetch_add(
|
||||
other.duplicate_name_count.load(Ordering::Relaxed),
|
||||
Ordering::Relaxed,
|
||||
);
|
||||
self.rbxm_fallback_count.fetch_add(
|
||||
other.rbxm_fallback_count.load(Ordering::Relaxed),
|
||||
Ordering::Relaxed,
|
||||
);
|
||||
self.unknown_class_count.fetch_add(
|
||||
other.unknown_class_count.load(Ordering::Relaxed),
|
||||
Ordering::Relaxed,
|
||||
);
|
||||
self.unknown_property_count.fetch_add(
|
||||
other.unknown_property_count.load(Ordering::Relaxed),
|
||||
Ordering::Relaxed,
|
||||
);
|
||||
|
||||
if let (Ok(mut self_classes), Ok(other_classes)) =
|
||||
(self.unknown_classes.lock(), other.unknown_classes.lock())
|
||||
{
|
||||
self_classes.extend(other_classes.iter().cloned());
|
||||
}
|
||||
|
||||
if let (Ok(mut self_props), Ok(other_props)) = (
|
||||
self.unknown_properties.lock(),
|
||||
other.unknown_properties.lock(),
|
||||
) {
|
||||
self_props.extend(other_props.iter().cloned());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_stats_tracking() {
|
||||
let stats = SyncbackStats::new();
|
||||
|
||||
assert!(!stats.has_issues());
|
||||
|
||||
stats.record_duplicate_name("Root/Folder", "Script");
|
||||
stats.record_duplicate_name("Root/Folder", "Script");
|
||||
assert_eq!(stats.duplicate_name_count(), 2);
|
||||
|
||||
stats.record_rbxm_fallback("Root/Model", "cannot represent as directory");
|
||||
assert_eq!(stats.rbxm_fallback_count(), 1);
|
||||
|
||||
stats.record_unknown_class("MyCustomClass");
|
||||
stats.record_unknown_class("MyCustomClass"); // duplicate
|
||||
assert_eq!(stats.unknown_class_count(), 2);
|
||||
assert_eq!(stats.unknown_classes().len(), 1); // unique
|
||||
|
||||
stats.record_unknown_property("Part", "CustomProp");
|
||||
assert_eq!(stats.unknown_property_count(), 1);
|
||||
|
||||
assert!(stats.has_issues());
|
||||
assert!(stats.has_unknown_types());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_batch_recording() {
|
||||
let stats = SyncbackStats::new();
|
||||
|
||||
stats.record_duplicate_names_batch("Root/Folder", &["Script", "Model"], 4);
|
||||
assert_eq!(stats.duplicate_name_count(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_merge() {
|
||||
let stats1 = SyncbackStats::new();
|
||||
let stats2 = SyncbackStats::new();
|
||||
|
||||
stats1.record_duplicate_name("path1", "name1");
|
||||
stats2.record_duplicate_name("path2", "name2");
|
||||
stats2.record_unknown_class("Class1");
|
||||
|
||||
stats1.merge(&stats2);
|
||||
|
||||
assert_eq!(stats1.duplicate_name_count(), 2);
|
||||
assert_eq!(stats1.unknown_classes().len(), 1);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue