kreuzberg 4.1.2 → 4.2.1

data/vendor/kreuzberg/src/plugins/registry/processor.rs

@@ -32,11 +32,33 @@ impl PostProcessorRegistry {
         let name = processor.name().to_string();
         let stage = processor.processing_stage();
 
-        super::validate_plugin_name(&name)?;
+        if let Err(e) = super::validate_plugin_name(&name) {
+            tracing::warn!(
+                "Failed to validate post-processor name '{}': {}. \
+                 Registration aborted. Plugin names must be non-empty and contain only alphanumeric characters, hyphens, and underscores.",
+                name,
+                e
+            );
+            return Err(e);
+        }
 
-        processor.initialize()?;
+        if let Err(e) = processor.initialize() {
+            tracing::error!(
+                "Failed to initialize post-processor '{}' for processing stage {:?} with priority {}: {}. \
+                 Post-processing step will not be executed.",
+                name,
+                stage,
+                priority,
+                e
+            );
+            return Err(e);
+        }
 
         if self.name_index.contains_key(&name) {
+            tracing::debug!(
+                "Post-processor '{}' is already registered. Removing old instance and registering new one.",
+                name
+            );
             self.remove(&name)?;
         }
 
@@ -47,7 +69,13 @@ impl PostProcessorRegistry {
             .or_default()
             .push(Arc::clone(&processor));
 
-        self.name_index.insert(name, (stage, priority));
+        self.name_index.insert(name.clone(), (stage, priority));
+        tracing::debug!(
+            "Registered post-processor '{}' for stage {:?} with priority {}",
+            name,
+            stage,
+            priority
+        );
 
         Ok(())
     }
@@ -84,7 +112,13 @@ impl PostProcessorRegistry {
     pub fn remove(&mut self, name: &str) -> Result<()> {
         let (stage, priority) = match self.name_index.remove(name) {
             Some(location) => location,
-            None => return Ok(()),
+            None => {
+                tracing::debug!(
+                    "Post-processor '{}' not found in registry (already removed or never registered)",
+                    name
+                );
+                return Ok(());
+            }
         };
 
         let processor_to_shutdown = if let Some(priority_map) = self.processors.get_mut(&stage) {
@@ -110,7 +144,16 @@ impl PostProcessorRegistry {
         };
 
         if let Some(processor) = processor_to_shutdown {
-            processor.shutdown()?;
+            if let Err(e) = processor.shutdown() {
+                tracing::warn!(
+                    "Failed to shutdown post-processor '{}': {}. \
+                     Resources may not have been properly released.",
+                    name,
+                    e
+                );
+                return Err(e);
+            }
+            tracing::debug!("Successfully removed and shut down post-processor '{}'", name);
         }
 
         Ok(())
@@ -119,9 +162,19 @@ impl PostProcessorRegistry {
     /// Shutdown all processors and clear the registry.
     pub fn shutdown_all(&mut self) -> Result<()> {
         let names = self.list();
+        let count = names.len();
+
+        if count > 0 {
+            tracing::debug!("Shutting down {} post-processors", count);
+        }
+
         for name in names {
             self.remove(&name)?;
         }
+
+        if count > 0 {
+            tracing::debug!("Successfully shut down all {} post-processors", count);
+        }
         Ok(())
     }
 }
@@ -301,4 +354,159 @@ mod tests {
         let processors = registry.get_for_stage(ProcessingStage::Late);
         assert_eq!(processors.len(), 0);
     }
+
+    struct FailingPostProcessor {
+        name: String,
+        stage: ProcessingStage,
+        fail_on_init: bool,
+    }
+
+    impl Plugin for FailingPostProcessor {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn version(&self) -> String {
+            "1.0.0".to_string()
+        }
+        fn initialize(&self) -> Result<()> {
+            if self.fail_on_init {
+                Err(KreuzbergError::Plugin {
+                    message: "Processor initialization failed".to_string(),
+                    plugin_name: self.name.clone(),
+                })
+            } else {
+                Ok(())
+            }
+        }
+        fn shutdown(&self) -> Result<()> {
+            Ok(())
+        }
+    }
+
+    #[async_trait]
+    impl PostProcessor for FailingPostProcessor {
+        async fn process(&self, _result: &mut ExtractionResult, _: &ExtractionConfig) -> Result<()> {
+            Ok(())
+        }
+
+        fn processing_stage(&self) -> ProcessingStage {
+            self.stage
+        }
+    }
+
+    #[test]
+    fn test_post_processor_initialization_failure_logs_error() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let processor = Arc::new(FailingPostProcessor {
+            name: "failing-processor".to_string(),
+            stage: ProcessingStage::Early,
+            fail_on_init: true,
+        });
+
+        let result = registry.register(processor, 50);
+        assert!(result.is_err());
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_post_processor_invalid_name_empty_logs_warning() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let processor = Arc::new(MockPostProcessor {
+            name: "".to_string(),
+            stage: ProcessingStage::Early,
+        });
+
+        let result = registry.register(processor, 50);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_post_processor_invalid_name_with_spaces_logs_warning() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let processor = Arc::new(MockPostProcessor {
+            name: "invalid processor".to_string(),
+            stage: ProcessingStage::Early,
+        });
+
+        let result = registry.register(processor, 50);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_post_processor_successful_registration_logs_debug() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let processor = Arc::new(MockPostProcessor {
+            name: "valid-processor".to_string(),
+            stage: ProcessingStage::Early,
+        });
+
+        let result = registry.register(processor, 50);
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 1);
+    }
+
+    #[test]
+    fn test_post_processor_remove_nonexistent_logs_debug() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let result = registry.remove("nonexistent-processor");
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_post_processor_register_same_name_twice() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let processor = Arc::new(MockPostProcessor {
+            name: "duplicate-processor".to_string(),
+            stage: ProcessingStage::Early,
+        });
+
+        registry.register(processor.clone(), 50).unwrap();
+        assert_eq!(registry.list().len(), 1);
+
+        registry.register(processor, 75).unwrap();
+        assert_eq!(registry.list().len(), 1);
+    }
+
+    #[test]
+    fn test_post_processor_multiple_stages() {
+        let mut registry = PostProcessorRegistry::new();
+
+        let early_processor = Arc::new(MockPostProcessor {
+            name: "early-proc".to_string(),
+            stage: ProcessingStage::Early,
+        });
+
+        let middle_processor = Arc::new(MockPostProcessor {
+            name: "middle-proc".to_string(),
+            stage: ProcessingStage::Middle,
+        });
+
+        let late_processor = Arc::new(MockPostProcessor {
+            name: "late-proc".to_string(),
+            stage: ProcessingStage::Late,
+        });
+
+        registry.register(early_processor, 100).unwrap();
+        registry.register(middle_processor, 50).unwrap();
+        registry.register(late_processor, 25).unwrap();
+
+        assert_eq!(registry.get_for_stage(ProcessingStage::Early).len(), 1);
+        assert_eq!(registry.get_for_stage(ProcessingStage::Middle).len(), 1);
+        assert_eq!(registry.get_for_stage(ProcessingStage::Late).len(), 1);
+    }
+
+    #[test]
+    fn test_post_processor_shutdown_empty_registry() {
+        let mut registry = PostProcessorRegistry::new();
+        let result = registry.shutdown_all();
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 0);
+    }
 }

data/vendor/kreuzberg/src/plugins/registry/validator.rs

@@ -30,11 +30,32 @@ impl ValidatorRegistry {
         let name = validator.name().to_string();
         let priority = validator.priority();
 
-        super::validate_plugin_name(&name)?;
+        if let Err(e) = super::validate_plugin_name(&name) {
+            tracing::warn!(
+                "Failed to validate validator name '{}': {}. \
+                 Registration aborted. Plugin names must be non-empty and contain only alphanumeric characters, hyphens, and underscores.",
+                name,
+                e
+            );
+            return Err(e);
+        }
 
-        validator.initialize()?;
+        if let Err(e) = validator.initialize() {
+            tracing::error!(
+                "Failed to initialize validator '{}' with priority {}: {}. \
+                 Validation step will not be executed.",
+                name,
+                priority,
+                e
+            );
+            return Err(e);
+        }
 
-        self.validators.entry(priority).or_default().insert(name, validator);
+        self.validators
+            .entry(priority)
+            .or_default()
+            .insert(name.clone(), validator);
+        tracing::debug!("Registered validator '{}' with priority {}", name, priority);
 
         Ok(())
     }
@@ -68,17 +89,35 @@ impl ValidatorRegistry {
     /// Remove a validator from the registry.
     pub fn remove(&mut self, name: &str) -> Result<()> {
         let mut validator_to_shutdown: Option<Arc<dyn Validator>> = None;
+        let mut found = false;
 
         for validators in self.validators.values_mut() {
             if let Some(validator) = validators.shift_remove(name)
                 && validator_to_shutdown.is_none()
             {
                 validator_to_shutdown = Some(validator);
+                found = true;
             }
         }
 
+        if !found {
+            tracing::debug!(
+                "Validator '{}' not found in registry (already removed or never registered)",
+                name
+            );
+        }
+
         if let Some(validator) = validator_to_shutdown {
-            validator.shutdown()?;
+            if let Err(e) = validator.shutdown() {
+                tracing::warn!(
+                    "Failed to shutdown validator '{}': {}. \
+                     Resources may not have been properly released.",
+                    name,
+                    e
+                );
+                return Err(e);
+            }
+            tracing::debug!("Successfully removed and shut down validator '{}'", name);
         }
 
         self.validators.retain(|_, validators| !validators.is_empty());
@@ -89,9 +128,19 @@ impl ValidatorRegistry {
     /// Shutdown all validators and clear the registry.
     pub fn shutdown_all(&mut self) -> Result<()> {
         let names = self.list();
+        let count = names.len();
+
+        if count > 0 {
+            tracing::debug!("Shutting down {} validators", count);
+        }
+
         for name in names {
             self.remove(&name)?;
         }
+
+        if count > 0 {
+            tracing::debug!("Successfully shut down all {} validators", count);
+        }
         Ok(())
     }
 }
@@ -235,4 +284,171 @@ mod tests {
         registry.shutdown_all().unwrap();
         assert_eq!(registry.get_all().len(), 0);
     }
+
+    struct FailingValidator {
+        name: String,
+        priority: i32,
+        fail_on_init: bool,
+    }
+
+    impl Plugin for FailingValidator {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn version(&self) -> String {
+            "1.0.0".to_string()
+        }
+        fn initialize(&self) -> Result<()> {
+            if self.fail_on_init {
+                Err(KreuzbergError::Plugin {
+                    message: "Validator initialization failed".to_string(),
+                    plugin_name: self.name.clone(),
+                })
+            } else {
+                Ok(())
+            }
+        }
+        fn shutdown(&self) -> Result<()> {
+            Ok(())
+        }
+    }
+
+    #[async_trait]
+    impl Validator for FailingValidator {
+        async fn validate(&self, _: &ExtractionResult, _: &ExtractionConfig) -> Result<()> {
+            Ok(())
+        }
+
+        fn priority(&self) -> i32 {
+            self.priority
+        }
+    }
+
+    #[test]
+    fn test_validator_initialization_failure_logs_error() {
+        let mut registry = ValidatorRegistry::new();
+
+        let validator = Arc::new(FailingValidator {
+            name: "failing-validator".to_string(),
+            priority: 50,
+            fail_on_init: true,
+        });
+
+        let result = registry.register(validator);
+        assert!(result.is_err());
+        assert_eq!(registry.get_all().len(), 0);
+    }
+
+    #[test]
+    fn test_validator_invalid_name_empty_logs_warning() {
+        let mut registry = ValidatorRegistry::new();
+
+        let validator = Arc::new(MockValidator {
+            name: "".to_string(),
+            priority: 50,
+        });
+
+        let result = registry.register(validator);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_validator_successful_registration_logs_debug() {
+        let mut registry = ValidatorRegistry::new();
+
+        let validator = Arc::new(MockValidator {
+            name: "valid-validator".to_string(),
+            priority: 50,
+        });
+
+        let result = registry.register(validator);
+        assert!(result.is_ok());
+        assert_eq!(registry.get_all().len(), 1);
+    }
+
+    #[test]
+    fn test_validator_remove_nonexistent_logs_debug() {
+        let mut registry = ValidatorRegistry::new();
+
+        let result = registry.remove("nonexistent-validator");
+        assert!(result.is_ok());
+        assert_eq!(registry.get_all().len(), 0);
+    }
+
+    #[test]
+    fn test_validator_priority_ordering_reversed() {
+        let mut registry = ValidatorRegistry::new();
+
+        let high = Arc::new(MockValidator {
+            name: "high-priority".to_string(),
+            priority: 100,
+        });
+
+        let low = Arc::new(MockValidator {
+            name: "low-priority".to_string(),
+            priority: 10,
+        });
+
+        registry.register(low).unwrap();
+        registry.register(high).unwrap();
+
+        let validators = registry.get_all();
+        assert_eq!(validators.len(), 2);
+        assert_eq!(validators[0].name(), "high-priority");
+        assert_eq!(validators[1].name(), "low-priority");
+    }
+
+    #[test]
+    fn test_validator_multiple_same_priority() {
+        let mut registry = ValidatorRegistry::new();
+
+        let validator1 = Arc::new(MockValidator {
+            name: "validator-a".to_string(),
+            priority: 50,
+        });
+
+        let validator2 = Arc::new(MockValidator {
+            name: "validator-b".to_string(),
+            priority: 50,
+        });
+
+        let validator3 = Arc::new(MockValidator {
+            name: "validator-c".to_string(),
+            priority: 50,
+        });
+
+        registry.register(validator1).unwrap();
+        registry.register(validator2).unwrap();
+        registry.register(validator3).unwrap();
+
+        let validators = registry.get_all();
+        assert_eq!(validators.len(), 3);
+    }
+
+    #[test]
+    fn test_validator_shutdown_empty_registry() {
+        let mut registry = ValidatorRegistry::new();
+        let result = registry.shutdown_all();
+        assert!(result.is_ok());
+        assert_eq!(registry.get_all().len(), 0);
+    }
+
+    #[test]
+    fn test_validator_remove_and_readd() {
+        let mut registry = ValidatorRegistry::new();
+
+        let validator = Arc::new(MockValidator {
+            name: "test-validator".to_string(),
+            priority: 50,
+        });
+
+        registry.register(validator.clone()).unwrap();
+        assert_eq!(registry.get_all().len(), 1);
+
+        registry.remove("test-validator").unwrap();
+        assert_eq!(registry.get_all().len(), 0);
+
+        registry.register(validator).unwrap();
+        assert_eq!(registry.get_all().len(), 1);
+    }
 }