YAML Error Handling (#2747)

* refactor(annot): enhance YAML parsing error reporting and handle nested contexts

- Replaced `ParsingException` with `YamlParsingException` for improved error details.
- Introduced `YamlErrorRenderer` for visual error markers in YAML reports.
- Added support for nested parsing contexts in `YamlParsingException`.
- Improved validation logic and error messages in `NodeValidationUtils` and `MethodSetter`.
- Updated `GenericYamlParser` to enhance schema validation handling.

* refactor(yaml-parsing): rename `YamlParsingException` to `ConfigurationParsingException` and update related classes

- Replaced `YamlParsingException` with `ConfigurationParsingException` for better clarity in exception usage.
- Updated `GenericYamlParser` and test cases to align with the new exception class.
- Simplified exception handling and removed redundant YAML-related logic.

* refactor(yaml-parsing): remove unused parameters and simplify logic in parsing methods

- Eliminated redundant parameters from `resolveSpelValue` and `replaceMarkerWithError` methods.
- Improved clarity in conditionals flagged as always true or false, annotated with TODO comments for future review.
- Streamlined exception handling in `GenericYamlParser` and optimized parsing utility logic.

* add copyright headers and improve YAML context handling

- Added missing Apache License headers to multiple classes.
- Introduced `updateContext` in `ParsingContext` for enhanced YAML parsing context tracking.
- Fixed formatting and improved error handling logic in `YamlErrorRenderer`.
- Applied minor code cleanups in `MethodSetter` and `GenericYamlParser`.

* refactor(tests): remove redundant `System.out.println` calls and outdated YAML parsing test blocks

- Cleaned up unused debug statements in `YAMLParsingReportTest`.
- Removed obsolete and commented-out test sections to simplify and improve readability.
- Adjusted YAML error context validation to reflect updated parsing behavior.

* refactor(yaml-parsing): replace `YamlErrorRenderer` with `LineYamlErrorRenderer`

- Replaced `YamlErrorRenderer` with `LineYamlErrorRenderer` for improved line-based error rendering in YAML context.
- Removed obsolete `YamlErrorRenderer` class and its dependencies.
- Refactored `MethodSetter` and `ParsingContext` to enhance error handling and context tracking.
- Updated test cases to align with the new error rendering approach and improved YAML parsing validation logic.

* refactor(yaml-parsing): clean up null checks, update formatting, and remove unused constants

- Replaced `assertEquals(null, ...)` with `assertNull(...)` for better readability.
- Updated `ParsingContext#toString` with a modern `formatted` multi-line string.
- Removed unused `BASE_INDENT` constant from `LineYamlErrorRenderer`.

* refactor(yaml-parsing): improve error handling, logging, and simplify exception messages

- Added SLF4J logging to `MethodSetter` for detailed debug messages on missing methods/beans.
- Simplified `ConfigurationParsingException` message initialization in `GenericYamlParser`.
- Replaced redundant `System.out.println` call with direct usage of `renderErrorReport`.
- Enhanced error messages in `McYamlIntrospector` for clarity on list vs. object mismatches.
- Imported SLF4J and utility classes as part of code cleanup.

* refactor(yaml-parsing): fix typos, improve logging, and update generic handling

- Corrected typos in method names (e.g., `validateAgaistSchema` to `validateAgainstSchema`).
- Introduced additional debug logging in `GenericYamlParser` for enhanced error tracking.
- Updated generic type handling in `ParsingContext` and `NodeValidationUtils`.
- Improved exception message formatting for clarity.

* test(yaml-parsing): reformat YAML test cases and update validation methods

- Reformatted YAML sources in `YAMLParsingCollapsedTest` and `YAMLParsingTest` for consistent indentation.
- Replaced redundant inline structure definitions with properly aligned multi-line structures in test assertions.
- Updated exception validation logic to use `assertNull` and `assertTrue` for better clarity.

* test(tests): clean up redundant methods and minor fixes in YAML parsing tests

- Removed unused `rootCause` method from `YAMLParsingCollapsedTest`.
- Updated exception handling to ignore caught exceptions for clarity.
- Replaced `assertEquals(null, ...)` with `assertNull(...)` in `YAMLParsingTest`.
- Fixed minor formatting issues in test cases.

* refactor: standardize accessor methods in `ParsingContext` and update usages

- Updated `ParsingContext` to use consistent `get*` accessor methods.
- Replaced direct field accesses with the new accessor methods across all relevant classes and test files.
- Improved exception messages and updated formatting for enhanced readability and clarity.

* refactor: migrate `ParsingContext` to record, simplify exception handling in YAML tests

- Converted `ParsingContext` to a record for cleaner implementation.
- Updated YAML parsing tests to use the new `getRootCause` helper method with type assertions.
- Reintroduced a previously commented-out YAML parsing test with improved exception handling.

* refactor: clean up tests and improve annotation handling in YAML parsing

- Replaced `assertEquals(null, ...)` with `assertNull(...)` in `YAMLParsingErrorTest`.
- Added `@NotNull` annotation to `ParsingContext#toString` for improved null safety.
- Removed unused `assertSchemaErrorContains` method from `YAMLComponentsParsingTest`.
- Simplified `getRootCause` logic by removing redundant null checks.

Author: predic8

annot/pom.xml

@@ -12,19 +12,21 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
- --><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>service-proxy-annot</artifactId>
     <name>${project.artifactId}</name>
     <packaging>jar</packaging>
 
-	<parent>
-		<groupId>org.membrane-soa</groupId>
-		<artifactId>service-proxy-parent</artifactId>
-		<relativePath>../pom.xml</relativePath>
-		<version>7.0.7-SNAPSHOT</version>
-	</parent>
+    <parent>
+        <groupId>org.membrane-soa</groupId>
+        <artifactId>service-proxy-parent</artifactId>
+        <relativePath>../pom.xml</relativePath>
+        <version>7.0.7-SNAPSHOT</version>
+    </parent>
 
     <dependencies>
         <dependency>
@@ -64,6 +66,11 @@
             <artifactId>jakarta.annotation-api</artifactId>
             <version>3.0.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.jayway.jsonpath</groupId>
+            <artifactId>json-path</artifactId>
+            <version>2.10.0</version>
+        </dependency>
 
         <!-- Test dependencies -->
         <dependency>

annot/src/main/java/com/predic8/membrane/annot/MCChildElement.java

@@ -13,13 +13,13 @@
    limitations under the License. */
 package com.predic8.membrane.annot;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
+import static java.lang.annotation.ElementType.*;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Target(METHOD)
+@Retention(RUNTIME)
 public @interface MCChildElement {
 
     /**

annot/src/main/java/com/predic8/membrane/annot/bean/BeanFactory.java

@@ -15,15 +15,16 @@
 package com.predic8.membrane.annot.bean;
 
 import com.fasterxml.jackson.databind.*;
-import com.predic8.membrane.annot.beanregistry.BeanRegistry;
+import com.predic8.membrane.annot.beanregistry.*;
 import com.predic8.membrane.annot.util.*;
+import com.predic8.membrane.annot.yaml.*;
 import org.jetbrains.annotations.*;
 
 import java.lang.reflect.*;
 import java.util.*;
 import java.util.stream.*;
 
-import static com.predic8.membrane.annot.util.ReflectionUtil.isWrapperOfPrimitive;
+import static com.predic8.membrane.annot.util.ReflectionUtil.*;
 
 /**
  * Builds Java objects from a "bean" JSON node (YAML).

annot/src/main/java/com/predic8/membrane/annot/beanregistry/BeanContainer.java

@@ -16,7 +16,7 @@
 
 import com.predic8.membrane.annot.Grammar;
 import com.predic8.membrane.annot.bean.BeanFactory;
-import com.predic8.membrane.annot.yaml.GenericYamlParser;
+import com.predic8.membrane.annot.yaml.*;
 import org.jetbrains.annotations.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -30,7 +30,7 @@ public class BeanContainer {
     /**
      * The class of the bean.
      */
-    private final Class clazz;
+    private final Class<?> clazz;
     /**
      * Constructed bean after initialization.
      */
@@ -88,7 +88,11 @@ public String toString() {
                     grammar,
                     definition.getNode(),
                     registry);
-        } catch (Exception e) {
+        } catch (ConfigurationParsingException e) {
+            throw e;
+        }
+        catch (Exception e) {
+            log.error("Could not instantiate bean: {}", definition.getNode(), e);
             throw new RuntimeException(e);
         }
     }
@@ -101,7 +105,6 @@ public String toString() {
             return define(registry, grammar);
         }
 
-
         // Singleton: ensure define() runs at most once per BeanContainer.
         synchronized (this) {
             Object existing = getSingleton();

annot/src/main/java/com/predic8/membrane/annot/beanregistry/BeanRegistryImplementation.java

@@ -14,7 +14,6 @@
 package com.predic8.membrane.annot.beanregistry;
 
 import com.predic8.membrane.annot.*;
-import com.predic8.membrane.annot.bean.*;
 import com.predic8.membrane.annot.yaml.*;
 import org.jetbrains.annotations.*;
 import org.slf4j.*;
@@ -126,7 +125,10 @@ private void activationRun() {
                     bcs.remove(bc.getDefinition().getUid());
                 }
                 uidsToRemove.add(uidAction);
-            } catch (Exception e) {
+            } catch (ConfigurationParsingException e) {
+                throw e;
+            }
+            catch (Exception e) {
                 log.error("Could not handle {} {}/{}", uidAction.action,
                         bc.getDefinition().getNamespace(), bc.getDefinition().getName(), e);
                 throw new RuntimeException(e);
@@ -156,7 +158,6 @@ public Object resolve(String url) {
     public List<Object> getBeans() {
         return bcs.values().stream().filter(bd -> !bd.getDefinition().isComponent())
                 .map(bc -> bc.getOrCreate(this, grammar))
-                .filter(Objects::nonNull)
                 .toList();
     }
 
@@ -170,7 +171,6 @@ public <T> List<T> getBeans(Class<T> clazz) {
         return bcs.values().stream()
                 .filter(bd -> bd.produces(clazz))
                 .map(bc -> bc.getOrCreate(this, grammar))
-                .filter(Objects::nonNull)
                 .filter(clazz::isInstance)
                 .map(clazz::cast)
                 .toList();

annot/src/main/java/com/predic8/membrane/annot/yaml/ConfigurationParsingException.java

@@ -0,0 +1,62 @@
+/* Copyright 2026 predic8 GmbH, www.predic8.com
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+package com.predic8.membrane.annot.yaml;
+
+import com.fasterxml.jackson.core.*;
+import com.fasterxml.jackson.databind.*;
+
+import static com.predic8.membrane.annot.yaml.error.LineYamlErrorRenderer.renderErrorReport;
+
+public class ConfigurationParsingException extends RuntimeException {
+
+    private ParsingContext<?> parsingContext;
+    private JsonNode wrong;
+
+    public ConfigurationParsingException(String message) {
+        super(message);
+    }
+
+    public ConfigurationParsingException(Throwable cause) {
+        super(cause);
+    }
+
+    public ConfigurationParsingException(String message, Throwable cause, ParsingContext<?> pc) {
+        super(message, cause);
+        this.parsingContext = pc;
+    }
+
+    public ParsingContext<?> getParsingContext() {
+        return parsingContext;
+    }
+
+    public void setParsingContext(ParsingContext<?> parsingContext) {
+        this.parsingContext = parsingContext;
+    }
+
+    /**
+     * Returns a complete formatted error report including highlighted YAML.
+     */
+    public String getFormattedReport() throws JsonProcessingException {
+        return renderErrorReport(this.parsingContext);
+    }
+
+    public JsonNode getWrong() {
+        return wrong;
+    }
+
+    public void setWrong(JsonNode wrong) {
+        this.wrong = wrong;
+    }
+}