diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinder.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinder.kt
index 2b9c41f38..38eae572d 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinder.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinder.kt
@@ -6,6 +6,8 @@
 package io.openapiprocessor.core.converter
 
 import io.openapiprocessor.core.converter.mapping.*
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.RootStep
 import io.openapiprocessor.core.processor.mapping.v2.ResultStyle
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -22,7 +24,7 @@ class MappingFinder(mappings: MappingSettings) {
     )
 
     // path/method
-    fun getResultTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): ResultTypeMapping? {
+    fun getResultTypeMapping(query: MappingQuery): ResultTypeMapping? {
         log.trace("looking for result type mapping {}", query)
 
         val epMapping = repository.getEndpointResultTypeMapping(query)
@@ -38,7 +40,7 @@ class MappingFinder(mappings: MappingSettings) {
         return null
     }
 
-    fun findResultStyleMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): ResultStyle {
+    fun findResultStyleMapping(query: MappingQuery): ResultStyle {
         log.trace("looking for result style mapping {}", query)
 
         val epMapping = repository.getEndpointResultStyleMapping(query)
@@ -55,7 +57,7 @@ class MappingFinder(mappings: MappingSettings) {
     }
 
     // path/method
-    fun getSingleTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): TypeMapping? {
+    fun getSingleTypeMapping(query: MappingQuery): TypeMapping? {
         log.trace("looking for single type mapping {}", query)
 
         val epMapping = repository.getEndpointSingleTypeMapping(query)
@@ -72,7 +74,7 @@ class MappingFinder(mappings: MappingSettings) {
     }
 
     // path/method
-    fun getMultiTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): TypeMapping? {
+    fun getMultiTypeMapping(query: MappingQuery): TypeMapping? {
         log.trace("looking for multi type mapping {}", query)
 
         val epMapping = repository.getEndpointMultiTypeMapping(query)
@@ -100,45 +102,52 @@ class MappingFinder(mappings: MappingSettings) {
      * - global response type
      * - global type
      */
-    fun findAnyTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): TypeMapping? {
-        log.trace("looking for any type mapping {}", query)
+    fun findAnyTypeMapping(query: MappingQuery): TypeMapping? {
+        val step = RootStep("looking for any type mapping of", query)
+        try {
+            return findAnyTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val eppMapping = repository.findEndpointParameterTypeMapping(query)
+    private fun findAnyTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        val eppMapping = repository.findEndpointParameterTypeMapping(query, step)
         if (eppMapping != null) {
             return eppMapping
         }
 
-        val eppnMapping = repository.findEndpointParameterNameTypeMapping(query)
+        val eppnMapping = repository.findEndpointParameterNameTypeMapping(query, step)
         if (eppnMapping != null) {
             return eppnMapping.mapping
         }
 
-        val eprMapping = repository.findEndpointContentTypeMapping(query)
+        val eprMapping = repository.findEndpointContentTypeMapping(query, step)
         if (eprMapping != null) {
             return eprMapping.mapping
         }
 
-        val eptMapping = repository.findEndpointTypeMapping(query)
+        val eptMapping = repository.findEndpointTypeMapping(query, step)
         if (eptMapping != null) {
             return eptMapping
         }
 
-        val gpMapping = repository.findGlobalParameterTypeMapping(query)
+        val gpMapping = repository.findGlobalParameterTypeMapping(query, step)
         if (gpMapping != null) {
             return gpMapping
         }
 
-        val gpnMapping = repository.findGlobalParameterNameTypeMapping(query)
+        val gpnMapping = repository.findGlobalParameterNameTypeMapping(query, step)
         if (gpnMapping != null) {
             return gpnMapping.mapping
         }
 
-        val grMapping = repository.findGlobalContentTypeMapping(query)
+        val grMapping = repository.findGlobalContentTypeMapping(query, step)
         if (grMapping != null) {
             return grMapping.mapping
         }
 
-        val gtMapping = repository.findGlobalTypeMapping(query)
+        val gtMapping = repository.findGlobalTypeMapping(query, step)
         if (gtMapping != null) {
             return gtMapping
         }
@@ -146,16 +155,23 @@ class MappingFinder(mappings: MappingSettings) {
         return null
     }
 
-    // path/method/name???/format/type
-    fun findTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): TypeMapping? {
-        log.trace("looking for type mapping {}", query)
+    // path/method/name/format/type
+    fun findTypeMapping(query: MappingQuery): TypeMapping? {
+        val step = RootStep("looking for type mapping of", query)
+        try {
+            return findTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val epMapping = repository.findEndpointTypeMapping(query)
+    private fun findTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        val epMapping = repository.findEndpointTypeMapping(query, step)
         if (epMapping != null) {
             return epMapping
         }
 
-        val gMapping = repository.findGlobalTypeMapping(query)
+        val gMapping = repository.findGlobalTypeMapping(query, step)
         if(gMapping != null) {
             return gMapping
         }
@@ -173,64 +189,92 @@ class MappingFinder(mappings: MappingSettings) {
         )
     }
 
-    fun findAnnotationTypeMappings(query: io.openapiprocessor.core.converter.mapping.MappingQuery): List<AnnotationTypeMapping> {
-        log.trace("looking for annotation type mapping {}", query)
+    fun findAnnotationTypeMappings(query: MappingQuery): List<AnnotationTypeMapping> {
+        val step = RootStep("looking for annotation type mapping of", query)
+        try {
+            return findAnnotationTypeMappings(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val epMapping = repository.findEndpointAnnotationTypeMapping(query)
+    private fun findAnnotationTypeMappings(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
+        val epMapping = repository.findEndpointAnnotationTypeMapping(query, step)
         if (epMapping.isNotEmpty()) {
             return epMapping
         }
 
-        return repository.findGlobalAnnotationTypeMapping(query)
+        return repository.findGlobalAnnotationTypeMapping(query, step)
     }
 
-    fun findParameterTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): TypeMapping? {
-        log.trace("looking for parameter type mapping {}", query)
+    fun findParameterTypeMapping(query: MappingQuery): TypeMapping? {
+        val step = RootStep("looking for parameter type mapping of", query)
+        try {
+            return findParameterTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val epMapping = repository.findEndpointParameterTypeMapping(query)
+    private fun findParameterTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        val epMapping = repository.findEndpointParameterTypeMapping(query, step)
         if (epMapping != null) {
             return epMapping
         }
 
-        val gMapping = repository.findGlobalParameterTypeMapping(query)
-        if(gMapping != null) {
+        val gMapping = repository.findGlobalParameterTypeMapping(query, step)
+        if (gMapping != null) {
             return gMapping
         }
 
         return null
     }
 
-    // todo test variants
-    fun findAnnotationParameterTypeMappings(query: io.openapiprocessor.core.converter.mapping.MappingQuery): List<AnnotationTypeMapping> {
-        log.trace("looking for annotation parameter type mapping {}", query)
+    fun findAnnotationParameterTypeMappings(query: MappingQuery): List<AnnotationTypeMapping> {
+        val step = RootStep("looking for annotation parameter type mapping of", query)
+        try {
+            return findAnnotationParameterTypeMappings(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val eppMapping = repository.findEndpointAnnotationParameterTypeMappings(query)
+    // todo test variants
+    private fun findAnnotationParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
+        val eppMapping = repository.findEndpointAnnotationParameterTypeMappings(query, step)
         if (eppMapping.isNotEmpty()) {
             return eppMapping
         }
 
-        val epMapping = repository.findEndpointAnnotationTypeMapping(query)
+        val epMapping = repository.findEndpointAnnotationTypeMapping(query, step)
         if (epMapping.isNotEmpty()) {
             return epMapping
         }
 
-        val pMapping = repository.findGlobalAnnotationParameterTypeMappings(query)
+        val pMapping = repository.findGlobalAnnotationParameterTypeMappings(query, step)
         if (pMapping.isNotEmpty()) {
             return pMapping
         }
 
-        return repository.findGlobalAnnotationTypeMapping(query)
+        return repository.findGlobalAnnotationTypeMapping(query, step)
     }
 
-    fun findParameterNameTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): NameTypeMapping? {
-        log.trace("looking for parameter name type mapping {}", query)
+    fun findParameterNameTypeMapping(query: MappingQuery): NameTypeMapping? {
+        val step = RootStep("looking for parameter name type mapping of", query)
+        try {
+            return findParameterNameTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val epMapping = repository.findEndpointParameterNameTypeMapping(query)
+    private fun findParameterNameTypeMapping(query: MappingQuery, step: MappingStep): NameTypeMapping? {
+        val epMapping = repository.findEndpointParameterNameTypeMapping(query, step)
         if (epMapping != null) {
             return epMapping
         }
 
-        val gMapping = repository.findGlobalParameterNameTypeMapping(query)
+        val gMapping = repository.findGlobalParameterNameTypeMapping(query, step)
         if(gMapping != null) {
             return gMapping
         }
@@ -238,33 +282,58 @@ class MappingFinder(mappings: MappingSettings) {
         return null
     }
 
-    fun findAnnotationParameterNameTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): List<AnnotationNameMapping> {
-        log.trace("looking for annotation parameter name type mapping {}", query)
+    fun findAnnotationParameterNameTypeMapping(query: MappingQuery): List<AnnotationNameMapping> {
+        val step = RootStep("looking for annotation parameter name type mapping of", query)
+        try {
+            return findAnnotationParameterNameTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
+    }
 
-        val epMapping = repository.findEndpointAnnotationParameterNameTypeMapping(query)
+    private fun findAnnotationParameterNameTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationNameMapping> {
+        val epMapping = repository.findEndpointAnnotationParameterNameTypeMapping(query, step)
         if (epMapping.isNotEmpty()) {
             return epMapping
         }
 
-        return repository.findGlobalAnnotationParameterNameTypeMapping(query)
+        return repository.findGlobalAnnotationParameterNameTypeMapping(query, step)
     }
 
-    fun findAddParameterTypeMappings(query: io.openapiprocessor.core.converter.mapping.MappingQuery): List<AddParameterTypeMapping> {
-        val epMapping = repository.findEndpointAddParameterTypeMappings(query)
+    fun findAddParameterTypeMappings(query: MappingQuery): List<AddParameterTypeMapping> {
+        val step = RootStep("looking for additional parameter type mapping of", query)
+        try {
+            return findAddParameterTypeMappings(query, step)
+        } finally {
+            step.log()
+        }
+    }
+
+    private fun findAddParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AddParameterTypeMapping> {
+        val epMapping = repository.findEndpointAddParameterTypeMappings(query, step)
         if (epMapping.isNotEmpty()) {
             return epMapping
         }
 
-        return repository.findGlobalAddParameterTypeMappings()
+        return repository.findGlobalAddParameterTypeMappings(step)
+    }
+
+    fun findContentTypeMapping(query: MappingQuery): ContentTypeMapping? {
+        val step = RootStep("looking for content type type mapping of", query)
+        try {
+            return findContentTypeMapping(query, step)
+        } finally {
+            step.log()
+        }
     }
 
-    fun findContentTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): ContentTypeMapping? {
-        val epMapping = repository.findEndpointContentTypeMapping(query)
+    fun findContentTypeMapping(query: MappingQuery, step: MappingStep): ContentTypeMapping? {
+        val epMapping = repository.findEndpointContentTypeMapping(query, step)
         if (epMapping != null) {
             return epMapping
         }
 
-        val gMapping = repository.findGlobalContentTypeMapping(query)
+        val gMapping = repository.findGlobalContentTypeMapping(query, step)
         if(gMapping != null) {
             return gMapping
         }
@@ -272,7 +341,7 @@ class MappingFinder(mappings: MappingSettings) {
         return null
     }
 
-    fun findNullTypeMapping(query: io.openapiprocessor.core.converter.mapping.MappingQuery): NullTypeMapping? {
+    fun findNullTypeMapping(query: MappingQuery): NullTypeMapping? {
         return repository.getEndpointNullTypeMapping(query)
     }
 
@@ -288,21 +357,7 @@ class MappingFinder(mappings: MappingSettings) {
             .flatten()
     }
 
-    fun isEndpointExcluded(query: io.openapiprocessor.core.converter.mapping.MappingQuery): Boolean {
+    fun isEndpointExcluded(query: MappingQuery): Boolean {
         return repository.isEndpointExcluded(query)
     }
-
-    private fun splitTypeName(typeName: String): Pair<String, String?> {
-        val split = typeName
-                .split(":")
-                .map { it.trim() }
-
-        val type = split.component1()
-        var format: String? = null
-        if (split.size == 2) {
-            format = split.component2()
-        }
-
-        return Pair(type, format)
-    }
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinderQuery.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinderQuery.kt
index a52b42d74..49a18eee7 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinderQuery.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/MappingFinderQuery.kt
@@ -74,42 +74,53 @@ class MappingFinderQuery(
     override fun toString(): String {
         val parts = mutableListOf<String>()
 
-        if (path != null) {
-            parts.add("path: $path")
+        if (name != null) {
+            parts.add("name: '$name'")
         }
 
-        if (method != null) {
-            parts.add("method: $method")
-        }
+        if (path != null) {
+            var part = "path: "
 
-        if (name != null) {
-            parts.add("name: $name")
+            if (method != null) {
+                part += "$method "
+            }
+
+            part += "'$path'"
+            parts.add(part)
         }
 
-        if (format != null) {
-            parts.add("format: $format")
+        if (!contentType.isNullOrBlank()) {
+            parts.add("$contentType")
         }
 
         if (type != null) {
-            parts.add("type: $type")
+            var part = "type: '$type"
+            if (format != null) {
+                part += ":$format"
+            }
+            part += "'"
+            parts.add(part)
         }
 
-        if (contentType != null) {
-            parts.add("contentType: $contentType")
-        }
+        // flags
+        var flags = ""
 
         if (primitive) {
-            parts.add("primitive")
+            flags += "P"
         }
 
         if (array) {
-            parts.add("array")
+            flags += "A"
         }
 
         if (allowObject) {
-            parts.add("allow object")
+            flags += "O"
+        }
+
+        if (flags.isNotEmpty()) {
+            parts.add(flags)
         }
 
-        return parts.joinToString(", ")
+        return parts.joinToString(" ")
     }
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Annotation.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Annotation.kt
index 89dc6d4c1..8b7791d19 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Annotation.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Annotation.kt
@@ -19,19 +19,53 @@ class Annotation(
      * parameter key/value map.
      */
     val parameters: LinkedHashMap<String, ParameterValue> = linkedMapOf()
-)
+) {
+
+    override fun toString(): String {
+        return "$type${parameters()}"
+    }
+
+    private fun parameters(): String {
+        return if (parameters.isEmpty()) {
+            ""
+        } else {
+            parameters.map {
+                if (it.key.isEmpty()) {
+                    "${it.value}"
+                } else {
+                    "${it.key} = ${it.value}"
+                }
+            }
+            .joinToString(", ", "(", ")") {
+                it
+            }
+        }
+    }
+}
 
 interface ParameterValue {
     val value: String
     val import: String?
 }
 
-class SimpleParameterValue(override val value: String, override val import: String? = null): ParameterValue
+class SimpleParameterValue(override val value: String, override val import: String? = null)
+    : ParameterValue {
+
+    override fun toString(): String {
+        return value
+    }
+}
+
+class ClassParameterValue(private val clazz: String)
+    : ParameterValue {
 
-class ClassParameterValue(private val clazz: String): ParameterValue {
     override val value: String
         get() = clazz.substring(import.substringBeforeLast('.').length + 1)
 
     override val import: String
         get() = clazz.substringBeforeLast('.')
+
+    override fun toString(): String {
+        return clazz
+    }
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationNameTypeMappingDefault.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationNameTypeMappingDefault.kt
index c5c7f4aec..b8af74b19 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationNameTypeMappingDefault.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationNameTypeMappingDefault.kt
@@ -16,4 +16,9 @@ open class AnnotationNameTypeMappingDefault(
      */
     override val annotation: Annotation
 
-): Mapping, AnnotationNameMapping
+): Mapping, AnnotationNameMapping {
+
+    override fun toString(): String {
+        return "name: $name @ $annotation"
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationTypeMappingDefault.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationTypeMappingDefault.kt
index 5bbfaf4c9..33b927562 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationTypeMappingDefault.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/AnnotationTypeMappingDefault.kt
@@ -21,4 +21,17 @@ open class AnnotationTypeMappingDefault(
      */
     override val annotation: Annotation
 
-): Mapping, AnnotationTypeMapping
+): Mapping, AnnotationTypeMapping {
+
+    override fun toString(): String {
+        return "type: ${sourceType()} @ $annotation"
+    }
+
+    private fun sourceType(): String {
+        return if (sourceTypeFormat == null) {
+            sourceTypeName
+        } else {
+            "${sourceTypeName}:${sourceTypeFormat}"
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/ContentTypeMapping.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/ContentTypeMapping.kt
index 20991ce2f..ce82c3987 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/ContentTypeMapping.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/ContentTypeMapping.kt
@@ -19,4 +19,9 @@ class ContentTypeMapping(
      */
     val mapping: TypeMapping
 
-): Mapping
+): Mapping {
+
+    override fun toString(): String {
+        return "$contentType => $mapping"
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/EndpointMappings.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/EndpointMappings.kt
index 886092d18..6aaae86b9 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/EndpointMappings.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/EndpointMappings.kt
@@ -6,6 +6,8 @@
 package io.openapiprocessor.core.converter.mapping
 
 import io.openapiprocessor.core.converter.mapping.matcher.*
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MethodsStep
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.processor.mapping.v2.ResultStyle
 import org.slf4j.Logger
@@ -95,121 +97,141 @@ class EndpointMappings(
         return null
     }
 
-    fun findTypeMapping(query: MappingQuery): TypeMapping? {
+    fun findTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMapping = httpMethodMappings?.findTypeMapping(TypeMatcher(query))
-        if (methodMapping != null) {
-            log.trace("found endpoint method type mapping ({} {})", query.path, query.method)
-            return methodMapping
+        if (httpMethodMappings != null) {
+            val methodMapping = httpMethodMappings.findTypeMapping(TypeMatcher(query), step.add(MethodsStep(query)))
+            if (methodMapping != null) {
+                return methodMapping
+            }
         }
 
-        val mapping = mappings.findTypeMapping(TypeMatcher(query))
+        val mapping = mappings.findTypeMapping(TypeMatcher(query), step)
         if (mapping != null) {
-            log.trace("found endpoint type mapping ({})", query.path)
             return mapping
         }
 
         return null
     }
 
-    fun findAnnotationTypeMappings(query: MappingQuery): List<AnnotationTypeMapping> {
+    fun findAnnotationTypeMappings(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMappings = httpMethodMappings?.findAnnotationTypeMapping(AnnotationTypeMatcher(query))
-        if (!methodMappings.isNullOrEmpty()) {
-            log.trace("found endpoint method annotation type mappings ({} {})", query.path, query.method)
-            return methodMappings
+        if (httpMethodMappings != null) {
+            val methodMappings = httpMethodMappings.findAnnotationTypeMapping(
+                AnnotationTypeMatcher(query),
+                step.add(MethodsStep(query)))
+
+            if (methodMappings.isNotEmpty()) {
+                return methodMappings
+            }
         }
 
-        val mappings = mappings.findAnnotationTypeMapping(AnnotationTypeMatcher(query))
-        log.trace("found endpoint annotation type mapping ({})", query.path)
+        val mappings = mappings.findAnnotationTypeMapping(AnnotationTypeMatcher(query), step)
         return mappings
     }
 
-    fun findParameterTypeMapping(query: MappingQuery): TypeMapping? {
+    fun findParameterTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMapping = httpMethodMappings?.findParameterTypeMapping(TypeMatcher(query))
-        if (methodMapping != null) {
-            log.trace("found endpoint method parameter type mapping ({} {})", query.path, query.method)
-            return methodMapping
+        if (httpMethodMappings != null) {
+            val methodMapping = httpMethodMappings.findParameterTypeMapping(
+                TypeMatcher(query),
+                step.add(MethodsStep(query)))
+
+            if (methodMapping != null) {
+                return methodMapping
+            }
         }
 
-        val mapping = mappings.findParameterTypeMapping(TypeMatcher(query))
+        val mapping = mappings.findParameterTypeMapping(TypeMatcher(query), step)
         if (mapping != null) {
-            log.trace("found endpoint parameter type mapping ({})", query.path)
             return mapping
         }
 
         return null
     }
 
-    fun findAnnotationParameterTypeMapping(query: MappingQuery): List<AnnotationTypeMapping> {
+    fun findAnnotationParameterTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMappings = httpMethodMappings?.findAnnotationParameterTypeMapping(AnnotationTypeMatcher(query))
-        if (!methodMappings.isNullOrEmpty()) {
-            log.trace("found endpoint method annotation parameter type mappings ({} {})", query.path, query.method)
-            return methodMappings
+        if (httpMethodMappings != null) {
+            val methodMappings = httpMethodMappings.findAnnotationParameterTypeMapping(
+                AnnotationTypeMatcher(query),
+                step.add(MethodsStep(query)))
+
+            if (methodMappings.isNotEmpty()) {
+                return methodMappings
+            }
         }
 
-        val mappings = mappings.findAnnotationParameterTypeMapping(AnnotationTypeMatcher(query))
-        log.trace("found endpoint annotation parameter type mapping ({})", query.path)
+        val mappings = mappings.findAnnotationParameterTypeMapping(AnnotationTypeMatcher(query), step)
         return mappings
     }
 
-    fun findParameterNameTypeMapping(query: MappingQuery): NameTypeMapping? {
+    fun findParameterNameTypeMapping(query: MappingQuery, step: MappingStep): NameTypeMapping? {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMapping = httpMethodMappings?.findParameterNameTypeMapping(ParameterNameTypeMatcher(query))
-        if (methodMapping != null) {
-            log.trace("found endpoint method parameter name type mapping ({} {})", query.path, query.method)
-            return methodMapping
+        if (httpMethodMappings != null) {
+            val methodMapping = httpMethodMappings.findParameterNameTypeMapping(
+                ParameterNameTypeMatcher(query),
+                step.add(MethodsStep(query)))
+
+            if (methodMapping != null) {
+                return methodMapping
+            }
         }
 
-        val mapping = mappings.findParameterNameTypeMapping(ParameterNameTypeMatcher(query))
+        val mapping = mappings.findParameterNameTypeMapping(ParameterNameTypeMatcher(query), step)
         if (mapping != null) {
-            log.trace("found endpoint parameter name type mapping ({})", query.path)
             return mapping
         }
 
         return null
     }
 
-    fun findAnnotationParameterNameTypeMapping(query: MappingQuery): List<AnnotationNameMapping> {
+    fun findAnnotationParameterNameTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationNameMapping> {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMappings = httpMethodMappings?.findAnnotationParameterNameTypeMapping(
-            AnnotationParameterNameTypeMatcher(query))
-        if (!methodMappings.isNullOrEmpty()) {
-            log.trace("found endpoint method annotation parameter name type mappings ({} {})", query.path, query.method)
-            return methodMappings
+        if (httpMethodMappings != null) {
+            val methodMappings = httpMethodMappings.findAnnotationParameterNameTypeMapping(
+                AnnotationParameterNameTypeMatcher(query),
+                step.add(MethodsStep(query)))
+
+            if (methodMappings.isNotEmpty()) {
+                return methodMappings
+            }
         }
 
-        val mappings = mappings.findAnnotationParameterNameTypeMapping(AnnotationParameterNameTypeMatcher(query))
-        log.trace("found endpoint annotation parameter name type mapping ({})", query.path)
+        val mappings = mappings.findAnnotationParameterNameTypeMapping(AnnotationParameterNameTypeMatcher(query), step)
         return mappings
     }
 
-    fun findAddParameterTypeMappings(query: MappingQuery): List<AddParameterTypeMapping> {
+    fun findAddParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AddParameterTypeMapping> {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMappings = httpMethodMappings?.findAddParameterTypeMappings(AddParameterTypeMatcher())
-        if (!methodMappings.isNullOrEmpty()) {
-            log.trace("found endpoint method add parameter type mappings ({} {})", query.path, query.method)
-            return methodMappings
+        if (httpMethodMappings != null) {
+            val methodMappings = httpMethodMappings.findAddParameterTypeMappings(
+                AddParameterTypeMatcher(),
+                step.add(MethodsStep(query)))
+
+            if (methodMappings.isNotEmpty()) {
+                return methodMappings
+            }
         }
 
-        val mappings = mappings.findAddParameterTypeMappings(AddParameterTypeMatcher())
-        log.trace("found endpoint add parameter type mapping ({})", query.path)
+        val mappings = mappings.findAddParameterTypeMappings(AddParameterTypeMatcher(), step)
         return mappings
     }
 
-    fun findContentTypeMapping(query: MappingQuery): ContentTypeMapping? {
+    fun findContentTypeMapping(query: MappingQuery, step: MappingStep): ContentTypeMapping? {
         val httpMethodMappings = methodMappings[query.method]
-        val methodMapping = httpMethodMappings?.findContentTypeMapping(ContentTypeMatcher(query))
-        if (methodMapping != null) {
-            log.trace("found endpoint method content type mapping ({} {})", query.path, query.method)
-            return methodMapping
+        if (httpMethodMappings != null) {
+            val methodMapping = httpMethodMappings.findContentTypeMapping(
+                ContentTypeMatcher(query),
+                step.add(MethodsStep(query)))
+
+            if (methodMapping != null) {
+                return methodMapping
+            }
         }
 
-        val mapping = mappings.findContentTypeMapping(ContentTypeMatcher(query))
+        val mapping = mappings.findContentTypeMapping(ContentTypeMatcher(query), step)
         if (mapping != null) {
-            log.trace("found endpoint content type mapping ({})", query.path)
             return mapping
         }
 
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingBucket.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingBucket.kt
index 3bd1fba55..ef48e1097 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingBucket.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingBucket.kt
@@ -5,11 +5,14 @@
 
 package io.openapiprocessor.core.converter.mapping
 
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+
 fun interface MappingBucket {
     /**
      * filter the mapping(s) by the given filter.
      *
      * @param filter matching conditions
+     * @param step mapping trace collector
      */
-    fun filter(filter: MappingMatcher): List<Mapping>
+    fun filter(filter: MappingMatcher, step: MappingStep): List<Mapping>
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingMatcher.kt
index f7c7263c9..4073f6ad0 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingMatcher.kt
@@ -5,6 +5,8 @@
 
 package io.openapiprocessor.core.converter.mapping
 
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+
 fun interface MappingMatcher {
-    fun match(mapping: Mapping): Boolean
+    fun match(mapping: Mapping, step: MappingStep): Boolean
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingRepository.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingRepository.kt
index 67abd2c04..b75be2f0d 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingRepository.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/MappingRepository.kt
@@ -6,6 +6,9 @@
 package io.openapiprocessor.core.converter.mapping
 
 import io.openapiprocessor.core.converter.mapping.matcher.*
+import io.openapiprocessor.core.converter.mapping.steps.EndpointsStep
+import io.openapiprocessor.core.converter.mapping.steps.GlobalsStep
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
 import io.openapiprocessor.core.processor.mapping.v2.ResultStyle
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -33,36 +36,37 @@ class MappingRepository(
         return globalMappings.getMultiTypeMapping()
     }
 
-    fun findGlobalTypeMapping(query: MappingQuery): TypeMapping? {
-        return globalMappings.findTypeMapping(TypeMatcher(query))
+    fun findGlobalTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        return globalMappings.findTypeMapping(TypeMatcher(query), step.add(GlobalsStep()))
     }
 
-    fun findGlobalAnnotationTypeMapping(query: MappingQuery): List<AnnotationTypeMapping> {
-        return globalMappings.findAnnotationTypeMapping(AnnotationTypeMatcher(query))
+    fun findGlobalAnnotationTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
+        return globalMappings.findAnnotationTypeMapping(AnnotationTypeMatcher(query), step.add(GlobalsStep()))
     }
 
-    fun findGlobalParameterTypeMapping(query: MappingQuery): TypeMapping? {
-        return globalMappings.findParameterTypeMapping(TypeMatcher(query))
+    fun findGlobalParameterTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        return globalMappings.findParameterTypeMapping(TypeMatcher(query), step.add(GlobalsStep()))
     }
 
-    fun findGlobalAnnotationParameterTypeMappings(query: MappingQuery): List<AnnotationTypeMapping> {
-        return globalMappings.findAnnotationParameterTypeMapping(AnnotationTypeMatcher(query))
+    fun findGlobalAnnotationParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
+        return globalMappings.findAnnotationParameterTypeMapping(AnnotationTypeMatcher(query), step.add(GlobalsStep()))
     }
 
-    fun findGlobalParameterNameTypeMapping(query: MappingQuery): NameTypeMapping? {
-        return globalMappings.findParameterNameTypeMapping(ParameterNameTypeMatcher(query))
+    fun findGlobalParameterNameTypeMapping(query: MappingQuery, step: MappingStep): NameTypeMapping? {
+        return globalMappings.findParameterNameTypeMapping(ParameterNameTypeMatcher(query), step.add(GlobalsStep()))
     }
 
-    fun findGlobalAnnotationParameterNameTypeMapping(query: MappingQuery): List<AnnotationNameMapping> {
-        return globalMappings.findAnnotationParameterNameTypeMapping(AnnotationParameterNameTypeMatcher(query))
+    fun findGlobalAnnotationParameterNameTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationNameMapping> {
+        return globalMappings.findAnnotationParameterNameTypeMapping(AnnotationParameterNameTypeMatcher(query),
+            step.add(GlobalsStep()))
     }
 
-    fun findGlobalAddParameterTypeMappings(): List<AddParameterTypeMapping>  {
-        return globalMappings.findAddParameterTypeMappings(AddParameterTypeMatcher())
+    fun findGlobalAddParameterTypeMappings(step: MappingStep): List<AddParameterTypeMapping>  {
+        return globalMappings.findAddParameterTypeMappings(AddParameterTypeMatcher(), step.add(GlobalsStep()))
     }
 
-    fun findGlobalContentTypeMapping(query: MappingQuery): ContentTypeMapping? {
-        return globalMappings.findContentTypeMapping(ContentTypeMatcher(query))
+    fun findGlobalContentTypeMapping(query: MappingQuery, step: MappingStep): ContentTypeMapping? {
+        return globalMappings.findContentTypeMapping(ContentTypeMatcher(query), step.add(GlobalsStep()))
     }
 
     fun getEndpointResultTypeMapping(query: MappingQuery): ResultTypeMapping? {
@@ -85,40 +89,40 @@ class MappingRepository(
         return endpointMappings[query.path]?.getNullTypeMapping(query)
     }
 
-    fun findEndpointTypeMapping(query: MappingQuery): TypeMapping? {
-        return endpointMappings[query.path]?.findTypeMapping(query)
+    fun findEndpointTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        return endpointMappings[query.path]?.findTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointAnnotationTypeMapping(query: MappingQuery): List<AnnotationTypeMapping> {
-        val mappings = endpointMappings[query.path] ?: return emptyList()
-        return mappings.findAnnotationTypeMappings(query)
+    fun findEndpointAnnotationTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
+        val pathMappings = endpointMappings[query.path] ?: return emptyList()
+        return pathMappings.findAnnotationTypeMappings(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointParameterTypeMapping(query: MappingQuery): TypeMapping? {
-        return endpointMappings[query.path]?.findParameterTypeMapping(query)
+    fun findEndpointParameterTypeMapping(query: MappingQuery, step: MappingStep): TypeMapping? {
+        return endpointMappings[query.path]?.findParameterTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointAnnotationParameterTypeMappings(query: MappingQuery): List<AnnotationTypeMapping> {
+    fun findEndpointAnnotationParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AnnotationTypeMapping> {
         val mappings = endpointMappings[query.path] ?: return emptyList()
-        return mappings.findAnnotationParameterTypeMapping(query)
+        return mappings.findAnnotationParameterTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointParameterNameTypeMapping(query: MappingQuery): NameTypeMapping? {
-        return endpointMappings[query.path]?.findParameterNameTypeMapping(query)
+    fun findEndpointParameterNameTypeMapping(query: MappingQuery, step: MappingStep): NameTypeMapping? {
+        return endpointMappings[query.path]?.findParameterNameTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointAnnotationParameterNameTypeMapping(query: MappingQuery): List<AnnotationNameMapping> {
+    fun findEndpointAnnotationParameterNameTypeMapping(query: MappingQuery, step: MappingStep): List<AnnotationNameMapping> {
         val mappings = endpointMappings[query.path] ?: return emptyList()
-        return mappings.findAnnotationParameterNameTypeMapping(query)
+        return mappings.findAnnotationParameterNameTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointAddParameterTypeMappings(query: MappingQuery): List<AddParameterTypeMapping> {
+    fun findEndpointAddParameterTypeMappings(query: MappingQuery, step: MappingStep): List<AddParameterTypeMapping> {
         val mappings = endpointMappings[query.path] ?: return emptyList()
-        return mappings.findAddParameterTypeMappings(query)
+        return mappings.findAddParameterTypeMappings(query, step.add(EndpointsStep(query)))
     }
 
-    fun findEndpointContentTypeMapping(query: MappingQuery): ContentTypeMapping? {
-        return endpointMappings[query.path]?.findContentTypeMapping(query)
+    fun findEndpointContentTypeMapping(query: MappingQuery, step: MappingStep): ContentTypeMapping? {
+        return endpointMappings[query.path]?.findContentTypeMapping(query, step.add(EndpointsStep(query)))
     }
 
     fun findExtensionAnnotations(extension: String, value: String): List<AnnotationNameMapping> {
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Mappings.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Mappings.kt
index 9bce3e570..70bb13b65 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Mappings.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/Mappings.kt
@@ -5,6 +5,9 @@
 
 package io.openapiprocessor.core.converter.mapping
 
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.ParametersStep
+import io.openapiprocessor.core.converter.mapping.steps.TypesStep
 import io.openapiprocessor.core.processor.mapping.v2.ResultStyle
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -42,8 +45,8 @@ class Mappings(
         return nullTypeMapping
     }
 
-    fun findTypeMapping(filter: MappingMatcher): TypeMapping? {
-        val mappings = typeMappings.filter(filter)
+    fun findTypeMapping(filter: MappingMatcher, step: MappingStep): TypeMapping? {
+        val mappings = typeMappings.filter(filter, step.add(TypesStep()))
         if (mappings.isEmpty()) {
             return null
         }
@@ -55,8 +58,8 @@ class Mappings(
         return mappings.first() as TypeMapping
     }
 
-    fun findAnnotationTypeMapping(filter: MappingMatcher): List<AnnotationTypeMapping> {
-        val mappings = typeMappings.filter(filter)
+    fun findAnnotationTypeMapping(filter: MappingMatcher, step: MappingStep): List<AnnotationTypeMapping> {
+        val mappings = typeMappings.filter(filter, step.add(TypesStep()))
         if (mappings.isEmpty()) {
             return emptyList()
         }
@@ -64,8 +67,8 @@ class Mappings(
         return mappings.map { it as AnnotationTypeMapping }
     }
 
-    fun findParameterTypeMapping(filter: MappingMatcher): TypeMapping? {
-        val mappings = parameterTypeMappings.filter(filter)
+    fun findParameterTypeMapping(filter: MappingMatcher, step: MappingStep): TypeMapping? {
+        val mappings = parameterTypeMappings.filter(filter, step.add(ParametersStep()))
         if (mappings.isEmpty()) {
             return null
         }
@@ -77,8 +80,8 @@ class Mappings(
         return mappings.first() as TypeMapping
     }
 
-    fun findAnnotationParameterTypeMapping(filter: MappingMatcher): List<AnnotationTypeMapping> {
-        val mappings = parameterTypeMappings.filter(filter)
+    fun findAnnotationParameterTypeMapping(filter: MappingMatcher, step: MappingStep): List<AnnotationTypeMapping> {
+        val mappings = parameterTypeMappings.filter(filter, step.add(ParametersStep()))
         if (mappings.isEmpty()) {
             return emptyList()
         }
@@ -86,8 +89,8 @@ class Mappings(
         return mappings.map { it as AnnotationTypeMapping }
     }
 
-    fun findParameterNameTypeMapping(filter: MappingMatcher): NameTypeMapping? {
-        val mappings = parameterTypeMappings.filter(filter)
+    fun findParameterNameTypeMapping(filter: MappingMatcher, step: MappingStep): NameTypeMapping? {
+        val mappings = parameterTypeMappings.filter(filter, step.add(ParametersStep()))
         if (mappings.isEmpty()) {
             return null
         }
@@ -99,8 +102,8 @@ class Mappings(
         return mappings.first() as NameTypeMapping
     }
 
-    fun findAnnotationParameterNameTypeMapping(filter: MappingMatcher): List<AnnotationNameMapping> {
-        val mappings = parameterTypeMappings.filter(filter)
+    fun findAnnotationParameterNameTypeMapping(filter: MappingMatcher, step: MappingStep): List<AnnotationNameMapping> {
+        val mappings = parameterTypeMappings.filter(filter, step.add(ParametersStep()))
         if (mappings.isEmpty()) {
             return emptyList()
         }
@@ -108,8 +111,8 @@ class Mappings(
         return mappings.map { it as AnnotationNameMapping }
     }
 
-    fun findAddParameterTypeMappings(filter: MappingMatcher): List<AddParameterTypeMapping>  {
-        val mappings = parameterTypeMappings.filter(filter)
+    fun findAddParameterTypeMappings(filter: MappingMatcher, step: MappingStep): List<AddParameterTypeMapping>  {
+        val mappings = parameterTypeMappings.filter(filter, step.add(ParametersStep()))
         if (mappings.isEmpty()) {
             return emptyList()
         }
@@ -117,8 +120,8 @@ class Mappings(
         return mappings.map { it as AddParameterTypeMapping }
     }
 
-    fun findContentTypeMapping(filter: MappingMatcher): ContentTypeMapping? {
-        val mappings = responseTypeMappings.filter(filter)
+    fun findContentTypeMapping(filter: MappingMatcher, step: MappingStep): ContentTypeMapping? {
+        val mappings = responseTypeMappings.filter(filter, step)
         if (mappings.isEmpty()) {
             return null
         }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/NameTypeMapping.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/NameTypeMapping.kt
index 0153456d8..7a4312277 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/NameTypeMapping.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/NameTypeMapping.kt
@@ -23,7 +23,7 @@ class NameTypeMapping(
 ): Mapping {
 
     override fun toString(): String {
-        return "$parameterName => ${targetType()}"
+        return "name: $parameterName => ${targetType()}"
     }
 
     private fun targetType(): String {
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMapping.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMapping.kt
index 4b3e4ea09..d362b1e54 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMapping.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMapping.kt
@@ -55,7 +55,11 @@ class  TypeMapping @JvmOverloads constructor(
     }
 
     override fun toString(): String {
-        return "${sourceType()} => ${targetType()}"
+        return if (hasType()) {
+            "type: ${sourceType()} => ${targetType()}"
+        } else {
+            targetType()
+        }
     }
 
     private fun sourceType(): String {
@@ -77,6 +81,11 @@ class  TypeMapping @JvmOverloads constructor(
             genericTypes.joinToString(",", "<", ">") { it.toString() }
         }
     }
+
+    // it has no type if it is only used to configure a target type
+    private fun hasType(): Boolean {
+        return sourceTypeName != null
+    }
 }
 
 fun List<Mapping>.toTypeMapping(): List<TypeMapping> {
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMappings.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMappings.kt
index 985718e97..46e441dac 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMappings.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/TypeMappings.kt
@@ -5,6 +5,7 @@
 
 package io.openapiprocessor.core.converter.mapping
 
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
@@ -13,8 +14,8 @@ class TypeMappings(private val mappings: List<Mapping>): MappingBucket {
 
     constructor(vararg mapping: Mapping): this(mapping.toList())
 
-    override fun filter(filter: MappingMatcher): List<Mapping> {
+    override fun filter(filter: MappingMatcher, step: MappingStep): List<Mapping> {
         return mappings
-            .filter { filter.match(it) }
+            .filter { filter.match(it, step) }
     }
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AddParameterTypeMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AddParameterTypeMatcher.kt
index 7224d0ebf..972b76902 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AddParameterTypeMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AddParameterTypeMatcher.kt
@@ -8,9 +8,11 @@ package io.openapiprocessor.core.converter.mapping.matcher
 import io.openapiprocessor.core.converter.mapping.AddParameterTypeMapping
 import io.openapiprocessor.core.converter.mapping.Mapping
 import io.openapiprocessor.core.converter.mapping.MappingMatcher
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
 
 class AddParameterTypeMatcher: MappingMatcher {
-    override fun match(mapping: Mapping): Boolean {
+
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
         return mapping is AddParameterTypeMapping
     }
 
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationParameterNameTypeMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationParameterNameTypeMatcher.kt
index 88cd586c1..c7f59e8dc 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationParameterNameTypeMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationParameterNameTypeMatcher.kt
@@ -5,21 +5,23 @@
 
 package io.openapiprocessor.core.converter.mapping.matcher
 
-import io.openapiprocessor.core.converter.mapping.*
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.converter.mapping.AnnotationNameMapping
+import io.openapiprocessor.core.converter.mapping.Mapping
+import io.openapiprocessor.core.converter.mapping.MappingMatcher
+import io.openapiprocessor.core.converter.mapping.MappingQuery
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MatcherStep
 
 class AnnotationParameterNameTypeMatcher(private val query: MappingQuery): MappingMatcher {
-    val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    override fun match(mapping: Mapping): Boolean {
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
         if (mapping !is AnnotationNameMapping) {
-            log.trace("not matched: {}", mapping)
+            step.add(MatcherStep(mapping, false))
             return false
         }
 
         val match = mapping.name == query.name
-        log.trace("${if (match) "" else "not "}matched: {}", mapping)
+        step.add(MatcherStep(mapping, match))
         return match
     }
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationTypeMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationTypeMatcher.kt
index 282384a5e..4140340a3 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationTypeMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/AnnotationTypeMatcher.kt
@@ -5,16 +5,18 @@
 
 package io.openapiprocessor.core.converter.mapping.matcher
 
-import io.openapiprocessor.core.converter.mapping.*
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.converter.mapping.AnnotationTypeMapping
+import io.openapiprocessor.core.converter.mapping.Mapping
+import io.openapiprocessor.core.converter.mapping.MappingMatcher
+import io.openapiprocessor.core.converter.mapping.MappingQueryType
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MatcherStep
 
 class AnnotationTypeMatcher(private val query: MappingQueryType): MappingMatcher {
-    val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    override fun match(mapping: Mapping): Boolean {
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
         if (mapping !is AnnotationTypeMapping) {
-            log.trace("not matched: {}", mapping)
+            step.add(MatcherStep(mapping, false))
             return false
         }
 
@@ -27,7 +29,7 @@ class AnnotationTypeMatcher(private val query: MappingQueryType): MappingMatcher
                 || (matchType && matchFormat)
                 || (query.allowObject && matchObject)
 
-        log.trace("${if (match) "" else "not "}matched: {}", mapping)
+        step.add(MatcherStep(mapping, match))
         return match
     }
 
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ContentTypeMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ContentTypeMatcher.kt
index 36dac9e1e..135d2f7ef 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ContentTypeMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ContentTypeMatcher.kt
@@ -6,20 +6,19 @@
 package io.openapiprocessor.core.converter.mapping.matcher
 
 import io.openapiprocessor.core.converter.mapping.*
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MatcherStep
 
 class ContentTypeMatcher(private val query: MappingQuery): MappingMatcher, (ContentTypeMapping) -> Boolean {
-    val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    override fun match(mapping: Mapping): Boolean {
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
         if (mapping !is ContentTypeMapping) {
-            log.trace("not matched: {}", mapping)
+            step.add(MatcherStep(mapping, false))
             return false
         }
 
         val match = this.invoke(mapping)
-        log.trace("${if (match) "" else "not "}matched: {}", mapping)
+        step.add(MatcherStep(mapping, match))
         return match
     }
 
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ParameterNameTypeMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ParameterNameTypeMatcher.kt
index d3ec4ed3e..58c343111 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ParameterNameTypeMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/ParameterNameTypeMatcher.kt
@@ -6,20 +6,19 @@
 package io.openapiprocessor.core.converter.mapping.matcher
 
 import io.openapiprocessor.core.converter.mapping.*
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MatcherStep
 
 class ParameterNameTypeMatcher(private val query: MappingQuery): MappingMatcher {
-    val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    override fun match(mapping: Mapping): Boolean {
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
         if (mapping !is NameTypeMapping) {
-            log.trace("not matched: {}", mapping)
+            step.add(MatcherStep(mapping, false))
             return false
         }
 
         val match = mapping.parameterName == query.name
-        log.trace("${if (match) "" else "not "}matched: {}", mapping)
+        step.add(MatcherStep(mapping, match))
         return match
     }
 }
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/TypeMatcher.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/TypeMatcher.kt
index c016b66e3..2d7501c65 100644
--- a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/TypeMatcher.kt
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/matcher/TypeMatcher.kt
@@ -5,24 +5,26 @@
 
 package io.openapiprocessor.core.converter.mapping.matcher
 
-import io.openapiprocessor.core.converter.mapping.*
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.converter.mapping.Mapping
+import io.openapiprocessor.core.converter.mapping.MappingMatcher
+import io.openapiprocessor.core.converter.mapping.MappingQuery
+import io.openapiprocessor.core.converter.mapping.TypeMapping
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MatcherStep
 
 /**
  * [io.openapiprocessor.core.converter.MappingFinder] matcher for type mappings.
  */
 class TypeMatcher(private val query: MappingQuery): MappingMatcher, (TypeMapping) -> Boolean {
-    val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    override fun match(mapping: Mapping): Boolean {
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
         if (mapping !is TypeMapping) {
-            log.trace("not matched: {}", mapping)
+            step.add(MatcherStep(mapping, false))
             return false
         }
 
         val match = this.invoke(mapping)
-        log.trace("${if (match) "" else "not "}matched: {}", mapping)
+        step.add(MatcherStep(mapping, match))
         return match
     }
 
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ContentTypesStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ContentTypesStep.kt
new file mode 100644
index 000000000..24be22499
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ContentTypesStep.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class ContentTypesStep: ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        return step is ContentTypesStep
+    }
+
+    override fun log(indent: String) {
+        if (!hasMappings()) {
+            return
+        }
+
+        val prefix = if (isMatch()) {
+            "$indent$MATCH"
+        } else {
+            "$indent$NO_MATCH"
+        }
+
+        log.trace(prefix, "responses")
+        steps.forEach {
+            it.log("$indent  ")
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/EndpointsStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/EndpointsStep.kt
new file mode 100644
index 000000000..7da8381ad
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/EndpointsStep.kt
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import io.openapiprocessor.core.converter.mapping.MappingQuery
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class EndpointsStep(val query: MappingQuery): ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        if (step !is EndpointsStep) {
+            return false
+        }
+
+        return query.path == step.query.path
+    }
+
+    override fun log(indent: String) {
+        if (!hasMappings()) {
+            return
+        }
+
+        val prefix = if (isMatch()) {
+            "$indent$MATCH"
+        } else {
+            "$indent$NO_MATCH"
+        }
+
+        log.trace(prefix, query.path)
+        steps.forEach {
+            it.log("$indent  ")
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/GlobalsStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/GlobalsStep.kt
new file mode 100644
index 000000000..7accc50ec
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/GlobalsStep.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class GlobalsStep: ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        return step is GlobalsStep
+    }
+
+    override fun log(indent: String) {
+        if (!hasMappings()) {
+            return
+        }
+
+        val prefix = if (isMatch()) {
+            "$indent$MATCH"
+        } else {
+            "$indent$NO_MATCH"
+        }
+
+        log.trace(prefix, "global")
+        steps.forEach {
+            it.log("$indent  ")
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ItemsStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ItemsStep.kt
new file mode 100644
index 000000000..2ee7ee340
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ItemsStep.kt
@@ -0,0 +1,14 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+abstract class ItemsStep: MappingStep {
+    protected val steps: MutableCollection<MappingStep> = ArrayList()
+
+    override fun isMatch(): Boolean {
+        return steps.any { it.isMatch() }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MappingStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MappingStep.kt
new file mode 100644
index 000000000..fae3f1183
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MappingStep.kt
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+interface MappingStep {
+    fun isMatch(): Boolean
+    fun hasMappings(): Boolean
+    fun add(step: MappingStep): MappingStep
+    fun isEqual(step: MappingStep): Boolean
+    fun log(indent: String = "")
+}
+
+const val MATCH = "+  {}"
+const val NO_MATCH = "-  {}"
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MatcherStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MatcherStep.kt
new file mode 100644
index 000000000..fcc9e7829
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MatcherStep.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import io.openapiprocessor.core.converter.mapping.Mapping
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class MatcherStep(val mapping: Mapping, val match: Boolean): MappingStep {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun isMatch(): Boolean {
+        return match
+    }
+
+    override fun hasMappings(): Boolean {
+        return true
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        TODO("never called")
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        return false
+    }
+
+    override fun log(indent: String) {
+        if (isMatch()) {
+            log.trace("$indent$MATCH", mapping)
+        } else {
+            log.trace("$indent$NO_MATCH", mapping)
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MethodsStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MethodsStep.kt
new file mode 100644
index 000000000..44d765cf4
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/MethodsStep.kt
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import io.openapiprocessor.core.converter.mapping.MappingQuery
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class MethodsStep(val query: MappingQuery): ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        if (step !is MethodsStep) {
+            return false
+        }
+
+        return query.method == step.query.method
+    }
+
+    override fun log(indent: String) {
+        if (!hasMappings()) {
+            return
+        }
+
+        val prefix = if (isMatch()) {
+            "$indent$MATCH"
+        } else {
+            "$indent$NO_MATCH"
+        }
+
+        log.trace(prefix, "methods")
+        steps.forEach {
+            it.log("$indent  ")
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ParametersStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ParametersStep.kt
new file mode 100644
index 000000000..a00695ff8
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/ParametersStep.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class ParametersStep(): ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        return step is ParametersStep
+    }
+
+    override fun log(indent: String) {
+        if (!hasMappings()) {
+            return
+        }
+
+        val prefix = if (isMatch()) {
+            "$indent$MATCH"
+        } else {
+            "$indent$NO_MATCH"
+        }
+
+        log.trace(prefix, "parameters")
+        steps.forEach {
+            it.log("$indent  ")
+        }
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/RootStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/RootStep.kt
new file mode 100644
index 000000000..5ed792a4d
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/RootStep.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import io.openapiprocessor.core.converter.mapping.MappingQuery
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class RootStep(val message: String = "", val query: MappingQuery) : ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun log(indent: String) {
+        log.trace("{} {}", message, query)
+        if (!hasMappings()) {
+            log.trace("$indent  $NO_MATCH", "no mappings")
+            return
+        }
+
+        steps.filter { it.hasMappings() }
+            .forEach { it.log("$indent  ") }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        return false
+    }
+}
diff --git a/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/TypesStep.kt b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/TypesStep.kt
new file mode 100644
index 000000000..ef30f3620
--- /dev/null
+++ b/openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/mapping/steps/TypesStep.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor-base/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.converter.mapping.steps
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+class TypesStep(): ItemsStep() {
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
+
+    override fun hasMappings(): Boolean {
+        return steps.any { it.hasMappings() }
+    }
+
+    override fun add(step: MappingStep): MappingStep {
+        val found = steps.find { it.isEqual(step) }
+        if(found != null) {
+            return found
+        }
+
+        steps.add(step)
+        return step
+    }
+
+    override fun isEqual(step: MappingStep): Boolean {
+        return step is TypesStep
+    }
+
+    override fun log(indent: String) {
+        if (!hasMappings()) {
+            return
+        }
+
+        val prefix = if (isMatch()) {
+            "$indent$MATCH"
+        } else {
+            "$indent$NO_MATCH"
+        }
+
+        log.trace(prefix, "types")
+        steps.forEach {
+            it.log("$indent  ")
+        }
+    }
+}
diff --git a/openapi-processor-core/src/test/groovy/io/openapiprocessor/core/processor/MappingConverterV2Spec.groovy b/openapi-processor-core/src/test/groovy/io/openapiprocessor/core/processor/MappingConverterV2Spec.groovy
index 4668ed871..8d62fe95a 100644
--- a/openapi-processor-core/src/test/groovy/io/openapiprocessor/core/processor/MappingConverterV2Spec.groovy
+++ b/openapi-processor-core/src/test/groovy/io/openapiprocessor/core/processor/MappingConverterV2Spec.groovy
@@ -5,7 +5,8 @@
 
 package io.openapiprocessor.core.processor
 
-
+import io.openapiprocessor.core.converter.mapping.steps.EndpointsStep
+import io.openapiprocessor.core.converter.mapping.steps.GlobalsStep
 import spock.lang.Specification
 import spock.lang.Subject
 
@@ -37,10 +38,10 @@ map:
                         null,
                         null,
                         null, null, null,
-                        "application/vnd.array"
-                        ,
+                        "application/vnd.array",
                         false,
-                        false))
+                        false),
+                new GlobalsStep())
 
         response.contentType == 'application/vnd.array'
         response.mapping.sourceTypeName == null
@@ -95,8 +96,7 @@ map:
         def mappingData = converter.convert (reader.read (yaml))
 
         then:
-        def endpoint = mappingData.endpointMappings["/foo"]
-        def parameter = endpoint.findParameterNameTypeMapping(query(
+        def query = query(
                 "/foo",
                 null,
                 "foo",
@@ -104,7 +104,9 @@ map:
                 null,
                 null,
                 false,
-                false))
+                false)
+        def endpoint = mappingData.endpointMappings["/foo"]
+        def parameter = endpoint.findParameterNameTypeMapping(query, new EndpointsStep(query))
 
         parameter.parameterName == 'foo'
         parameter.mapping.sourceTypeName == null
@@ -128,16 +130,18 @@ map:
         def mappingData = converter.convert (reader.read (yaml))
 
         then:
+        def query = query(
+                        "/foo",
+                        null,
+                        null,
+                        null,
+                        null,
+                        null,
+                        false,
+                        false)
         def endpoint = mappingData.endpointMappings["/foo"]
-        def parameters = endpoint.findAddParameterTypeMappings(query(
-                "/foo",
-                null,
-                null,
-                null,
-                null,
-                null,
-                false,
-                false))
+        def parameters = endpoint.findAddParameterTypeMappings(
+                query, new EndpointsStep(query))
 
         def parameter = parameters[0]
         parameter.parameterName == 'request'
@@ -162,16 +166,18 @@ map:
         def mappingData = converter.convert (reader.read (yaml))
 
         then:
+        def query = query(
+                        "/foo",
+                        null,
+                        null,
+                        null,
+                        null,
+                        null,
+                        false,
+                        false)
         def endpoint = mappingData.endpointMappings["/foo"]
-        def parameters = endpoint.findAddParameterTypeMappings(query(
-                "/foo",
-                null,
-                null,
-                null,
-                null,
-                null,
-                false,
-                false))
+        def parameters = endpoint.findAddParameterTypeMappings(
+                query, new EndpointsStep(query))
 
         def parameter = parameters[0]
         parameter.parameterName == 'foo'
@@ -199,16 +205,17 @@ map:
         def mappingData = converter.convert (reader.read (yaml))
 
         then:
+        def query = query(
+                        "/foo",
+                        null,
+                        null,
+                        "application/vnd.array",
+                        null,
+                        null,
+                        false,
+                        false)
         def endpoint = mappingData.endpointMappings["/foo"]
-        def response = endpoint.findContentTypeMapping(query(
-                "/foo",
-                null,
-                null,
-                "application/vnd.array",
-                null,
-                null,
-                false,
-                false))
+        def response = endpoint.findContentTypeMapping(query, new EndpointsStep(query))
 
         response.contentType == 'application/vnd.array'
         response.mapping.sourceTypeName == null
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/converter/DataTypeConverterMappingSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/converter/DataTypeConverterMappingSpec.kt
index 0cc9ebdf5..e05b36428 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/converter/DataTypeConverterMappingSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/converter/DataTypeConverterMappingSpec.kt
@@ -13,13 +13,11 @@ import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.nulls.shouldBeNull
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.types.shouldBeInstanceOf
+import io.openapiprocessor.core.converter.mapping.steps.GlobalsStep
 import io.openapiprocessor.core.model.DataTypes
 import io.openapiprocessor.core.model.datatypes.*
 import io.openapiprocessor.core.parser.HttpMethod
-import io.openapiprocessor.core.support.getParameterSchemaInfo
-import io.openapiprocessor.core.support.getSchemaInfo
-import io.openapiprocessor.core.support.parseApi
-import io.openapiprocessor.core.support.parseOptions
+import io.openapiprocessor.core.support.*
 import io.openapiprocessor.core.writer.java.JavaIdentifier
 
 class DataTypeConverterMappingSpec: StringSpec({
@@ -204,7 +202,7 @@ class DataTypeConverterMappingSpec: StringSpec({
             |    - add: add => additional.Parameter
             """)
 
-        val tm = options.globalMappings.findAddParameterTypeMappings { _ -> true }.first().mapping
+        val tm = options.globalMappings.findAddParameterTypeMappings(AnyMatcher(), GlobalsStep()).first().mapping
 
         // when:
         val converter = DataTypeConverter(options, identifier)
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterEndpointMethodSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterEndpointMethodSpec.kt
index 8cd917dd4..cf51f5183 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterEndpointMethodSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterEndpointMethodSpec.kt
@@ -12,6 +12,7 @@ import io.kotest.matchers.collections.shouldBeEmpty
 import io.kotest.matchers.maps.shouldHaveSize
 import io.kotest.matchers.nulls.shouldBeNull
 import io.kotest.matchers.shouldBe
+import io.openapiprocessor.core.converter.mapping.steps.EndpointsStep
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.processor.MappingConverter
 import io.openapiprocessor.core.processor.MappingReader
@@ -38,8 +39,10 @@ class MappingConverterEndpointMethodSpec: StringSpec({
         val mappingData = converter.convert(reader.read(yaml))
 
         mappingData.endpointMappings.shouldHaveSize(1)
+
+        val query = query(path = "/foo", method = HttpMethod.GET, name = "Foo")
         val epMappings = mappingData.endpointMappings["/foo"]
-        val mapping = epMappings?.findTypeMapping(query(path = "/foo", method = HttpMethod.GET, name = "Foo"))
+        val mapping = epMappings?.findTypeMapping(query, EndpointsStep(query))
 
         mapping!!.sourceTypeName shouldBe "Foo"
         mapping.sourceTypeFormat.shouldBeNull()
@@ -74,8 +77,10 @@ class MappingConverterEndpointMethodSpec: StringSpec({
             val mappingData = converter.convert(reader.read(yaml))
 
             mappingData.endpointMappings.shouldHaveSize(1)
+
+            val query = query(path = "/foo", method = method, name = "Foo")
             val epMappings = mappingData.endpointMappings["/foo"]
-            val mapping = epMappings?.findTypeMapping(query(path = "/foo", method = method, name = "Foo"))
+            val mapping = epMappings?.findTypeMapping(query, EndpointsStep(query))
 
             mapping!!.sourceTypeName shouldBe "Foo"
             mapping.sourceTypeFormat.shouldBeNull()
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterGenericsSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterGenericsSpec.kt
index 0a1d0b206..c7f19560b 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterGenericsSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterGenericsSpec.kt
@@ -11,9 +11,12 @@ import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.nulls.shouldBeNull
 import io.kotest.matchers.shouldBe
 import io.openapiprocessor.core.converter.mapping.matcher.AddParameterTypeMatcher
-import io.openapiprocessor.core.converter.mapping.matcher.ParameterNameTypeMatcher
 import io.openapiprocessor.core.converter.mapping.matcher.ContentTypeMatcher
+import io.openapiprocessor.core.converter.mapping.matcher.ParameterNameTypeMatcher
 import io.openapiprocessor.core.converter.mapping.matcher.TypeMatcher
+import io.openapiprocessor.core.converter.mapping.steps.ContentTypesStep
+import io.openapiprocessor.core.converter.mapping.steps.ParametersStep
+import io.openapiprocessor.core.converter.mapping.steps.TypesStep
 import io.openapiprocessor.core.processor.MappingConverter
 import io.openapiprocessor.core.processor.MappingReader
 import io.openapiprocessor.core.support.query
@@ -37,7 +40,7 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")))!!
+        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")), TypesStep())!!
 
         type.sourceTypeName shouldBe "Foo"
         type.sourceTypeFormat.shouldBeNull()
@@ -64,7 +67,7 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")))!!
+        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")), TypesStep())!!
 
         type.sourceTypeName shouldBe "Foo"
         type.sourceTypeFormat.shouldBeNull()
@@ -87,7 +90,7 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")))!!
+        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")), TypesStep())!!
 
         type.targetTypeName shouldBe "java.util.Map"
         type.genericTypes.size shouldBe 2
@@ -108,7 +111,7 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")))!!
+        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")), TypesStep())!!
 
         type.targetTypeName shouldBe "java.util.Map"
         type.genericTypes.size shouldBe 2
@@ -135,7 +138,7 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")))!!
+        val type = mappingData.globalMappings.findTypeMapping(TypeMatcher(query(name = "Foo")), TypesStep())!!
 
         type.targetTypeName shouldBe "java.util.Map"
         type.genericTypes.size shouldBe 2
@@ -159,7 +162,8 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findParameterNameTypeMapping(ParameterNameTypeMatcher(query(name = "foo")))!!
+        val type = mappingData.globalMappings.findParameterNameTypeMapping(
+            ParameterNameTypeMatcher(query(name = "foo")), ParametersStep())!!
 
         type.parameterName shouldBe "foo"
         val tm = type.mapping
@@ -185,7 +189,8 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findParameterNameTypeMapping(ParameterNameTypeMatcher(query(name = "foo")))!!
+        val type = mappingData.globalMappings.findParameterNameTypeMapping(
+            ParameterNameTypeMatcher(query(name = "foo")), ParametersStep())!!
 
         type.parameterName shouldBe "foo"
         val tm = type.mapping
@@ -214,7 +219,7 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val adds = mappingData.globalMappings.findAddParameterTypeMappings(AddParameterTypeMatcher())
+        val adds = mappingData.globalMappings.findAddParameterTypeMappings(AddParameterTypeMatcher(), ParametersStep())
 
         adds shouldHaveSize 1
         val type = adds.first()
@@ -246,7 +251,8 @@ class MappingConverterGenericsSpec: StringSpec({
                    """.trimMargin()
 
         val mappingData = converter.convert(reader.read(yaml))
-        val type = mappingData.globalMappings.findContentTypeMapping(ContentTypeMatcher(query(contentType = "foo/bar")))!!
+        val type = mappingData.globalMappings.findContentTypeMapping(
+            ContentTypeMatcher(query(contentType = "foo/bar")), ContentTypesStep())!!
 
         type.contentType shouldBe "foo/bar"
         val tm = type.mapping
@@ -275,7 +281,7 @@ class MappingConverterGenericsSpec: StringSpec({
 
         // when:
         val mappingData = converter.convert(reader.read(yaml))
-        val types = mappingData.globalMappings.findAddParameterTypeMappings(AddParameterTypeMatcher())
+        val types = mappingData.globalMappings.findAddParameterTypeMappings(AddParameterTypeMatcher(), ParametersStep())
 
         types shouldHaveSize 1
         val type = types.first()
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterParameterSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterParameterSpec.kt
index 094d01d73..032dca875 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterParameterSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterParameterSpec.kt
@@ -15,10 +15,12 @@ import io.kotest.matchers.shouldBe
 import io.mockk.mockk
 import io.openapiprocessor.core.converter.MappingFinderQuery
 import io.openapiprocessor.core.converter.mapping.AmbiguousTypeMappingException
+import io.openapiprocessor.core.converter.mapping.steps.EndpointsStep
+import io.openapiprocessor.core.converter.mapping.steps.GlobalsStep
+import io.openapiprocessor.core.converter.mapping.steps.ParametersStep
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.processor.MappingReader
 import io.openapiprocessor.core.support.*
-import io.openapiprocessor.core.support.annotationTypeMatcher
 import org.slf4j.Logger
 
 
@@ -39,7 +41,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val typeMapping = mappings.findParameterTypeMapping(typeMatcher(name = "Foo"))!!
+        val typeMapping = mappings.findParameterTypeMapping(typeMatcher(name = "Foo"), GlobalsStep())!!
 
         typeMapping.sourceTypeName shouldBe "Foo"
         typeMapping.targetTypeName shouldBe "mapping.Foo"
@@ -61,7 +63,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val typeMapping = mappings.findParameterTypeMapping(typeMatcher(name = "Foo"))
+        val typeMapping = mappings.findParameterTypeMapping(typeMatcher(name = "Foo"), GlobalsStep())
 
         typeMapping.shouldBeNull()
     }
@@ -83,7 +85,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         shouldThrow<AmbiguousTypeMappingException> {
-            mappings.findParameterTypeMapping(typeMatcher(name = "Foo"))
+            mappings.findParameterTypeMapping(typeMatcher(name = "Foo"), GlobalsStep())
         }
     }
 
@@ -100,7 +102,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val nameTypeMapping = mappings.findParameterNameTypeMapping(parameterNameMatcher(name = "foo"))!!
+        val nameTypeMapping = mappings.findParameterNameTypeMapping(parameterNameMatcher(name = "foo"), ParametersStep())!!
 
         nameTypeMapping.parameterName shouldBe "foo"
         nameTypeMapping.mapping.sourceTypeName.shouldBeNull()
@@ -123,7 +125,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val nameTypeMapping = mappings.findParameterNameTypeMapping(parameterNameMatcher(name = "foo"))
+        val nameTypeMapping = mappings.findParameterNameTypeMapping(parameterNameMatcher(name = "foo"), ParametersStep())
 
         nameTypeMapping.shouldBeNull()
     }
@@ -145,7 +147,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         shouldThrow<AmbiguousTypeMappingException> {
-            mappings.findParameterNameTypeMapping(parameterNameMatcher(name = "foo"))
+            mappings.findParameterNameTypeMapping(parameterNameMatcher(name = "foo"), ParametersStep())
         }
     }
 
@@ -163,7 +165,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val addMappings = mappings.findAddParameterTypeMappings(addParameterTypeMatcher())
+        val addMappings = mappings.findAddParameterTypeMappings(addParameterTypeMatcher(), ParametersStep())
 
         addMappings.shouldBeEmpty()
     }
@@ -181,7 +183,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val addMappings = mappings.findAddParameterTypeMappings(addParameterTypeMatcher())
+        val addMappings = mappings.findAddParameterTypeMappings(addParameterTypeMatcher(), ParametersStep())
 
         addMappings.size.shouldBe(1)
         val add = addMappings.first()
@@ -207,7 +209,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val addMappings = mappings.findAddParameterTypeMappings(addParameterTypeMatcher())
+        val addMappings = mappings.findAddParameterTypeMappings(addParameterTypeMatcher(), ParametersStep())
 
         addMappings.size.shouldBe(2)
         addMappings[0].parameterName shouldBe "foo"
@@ -229,7 +231,8 @@ class MappingConverterParameterSpec: StringSpec({
         val mapping = reader.read(yaml) as Mapping
         val mappings = MappingConverter(mapping).convert().globalMappings
 
-        val annotationMappings = mappings.findAnnotationParameterTypeMapping(annotationTypeMatcher(type = "Foo"))
+        val annotationMappings = mappings.findAnnotationParameterTypeMapping(
+            annotationTypeMatcher(type = "Foo"), ParametersStep())
 
          annotationMappings shouldHaveSize 1
          val annotationMapping = annotationMappings.first()
@@ -255,7 +258,8 @@ class MappingConverterParameterSpec: StringSpec({
          val mapping = reader.read (yaml) as Mapping
          val mappings = MappingConverter(mapping).convert().globalMappings
 
-         val annotationMappings = mappings.findAnnotationParameterTypeMapping(annotationTypeMatcher(type = "Foo"))
+         val annotationMappings = mappings.findAnnotationParameterTypeMapping(
+             annotationTypeMatcher(type = "Foo"), ParametersStep())
 
          annotationMappings shouldHaveSize 2
      }
@@ -274,7 +278,8 @@ class MappingConverterParameterSpec: StringSpec({
          val mappings = MappingConverter(mapping).convert().globalMappings
 
          // then:
-         val annotationMappings = mappings.findAnnotationParameterTypeMapping(annotationTypeMatcher(name = "Foo"))
+         val annotationMappings = mappings.findAnnotationParameterTypeMapping(
+             annotationTypeMatcher(name = "Foo"), ParametersStep())
 
          annotationMappings.shouldBeEmpty()
      }
@@ -295,7 +300,7 @@ class MappingConverterParameterSpec: StringSpec({
          val mappings = MappingConverter(mapping).convert().globalMappings
 
          val annotationMappings = mappings.findAnnotationParameterNameTypeMapping(
-             annotationParameterNameTypeMatcher(name = "foo"))
+             annotationParameterNameTypeMatcher(name = "foo"), ParametersStep())
 
          annotationMappings shouldHaveSize 1
          val annotationMapping = annotationMappings.first()
@@ -321,7 +326,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         val annotationMappings = mappings.findAnnotationParameterNameTypeMapping(
-            annotationParameterNameTypeMatcher(name = "foo"))
+            annotationParameterNameTypeMatcher(name = "foo"), ParametersStep())
 
         annotationMappings shouldHaveSize 2
     }
@@ -340,7 +345,8 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().globalMappings
 
         // then:
-        val annotationMappings = mappings.findAnnotationParameterNameTypeMapping(annotationTypeMatcher(name = "foo"))
+        val annotationMappings = mappings.findAnnotationParameterNameTypeMapping(
+            annotationTypeMatcher(name = "foo"), ParametersStep())
 
         annotationMappings.shouldBeEmpty()
     }
@@ -369,16 +375,15 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().endpointMappings
 
         // then:
-        val typeMapping = mappings["/foo"]!!.findParameterTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, name = "Foo"))!!
+        val postQuery = MappingFinderQuery(path = "/foo", method = HttpMethod.POST, name = "Foo")
+        val typeMapping = mappings["/foo"]!!.findParameterTypeMapping(postQuery, ParametersStep())!!
 
         typeMapping.sourceTypeName shouldBe "Foo"
         typeMapping.sourceTypeFormat.shouldBeNull()
         typeMapping.targetTypeName shouldBe "io.openapiprocessor.Foo"
 
-        val typeMappingGet = mappings["/foo"]!!.findParameterTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, name= "Foo")
-        )!!
+        val getQuery = MappingFinderQuery(path = "/foo", method = HttpMethod.GET, name= "Foo")
+        val typeMappingGet = mappings["/foo"]!!.findParameterTypeMapping(getQuery, ParametersStep())!!
 
         typeMappingGet.sourceTypeName shouldBe "Foo"
         typeMappingGet.sourceTypeFormat.shouldBeNull()
@@ -410,7 +415,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().endpointMappings
 
         val annotationMappings = mappings["/foo"]!!.findAnnotationParameterTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, type = "Foo"))
+            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, type = "Foo"), ParametersStep())
 
         annotationMappings shouldHaveSize 2
         annotationMappings[0].sourceTypeName shouldBe  "Foo"
@@ -423,8 +428,7 @@ class MappingConverterParameterSpec: StringSpec({
         annotationMappings[1].annotation.parameters.shouldBeEmpty()
 
         val annotationMappingsGet = mappings["/foo"]!!.findAnnotationParameterTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, type = "Foo")
-        )
+            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, type = "Foo"), ParametersStep())
 
         annotationMappingsGet shouldHaveSize 2
         annotationMappingsGet[0].sourceTypeName shouldBe  "Foo"
@@ -462,15 +466,14 @@ class MappingConverterParameterSpec: StringSpec({
 
         // then:
         val typeMapping = mappings["/foo"]!!.findParameterNameTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, name = "foo"))!!
+            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, name = "foo"), ParametersStep())!!
 
         typeMapping.parameterName shouldBe "foo"
         typeMapping.mapping.sourceTypeName.shouldBeNull()
         typeMapping.mapping.targetTypeName shouldBe "io.openapiprocessor.Foo"
 
         val typeMappingGet = mappings["/foo"]!!.findParameterNameTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, name= "foo")
-        )!!
+            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, name= "foo"), ParametersStep())!!
 
         typeMappingGet.parameterName shouldBe "foo"
         typeMappingGet.mapping.sourceTypeName.shouldBeNull()
@@ -502,7 +505,7 @@ class MappingConverterParameterSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().endpointMappings
 
         val annotationMappings = mappings["/foo"]!!.findAnnotationParameterNameTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, name = "foo"))
+            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, name = "foo"), ParametersStep())
 
         annotationMappings shouldHaveSize 2
         annotationMappings[0].name shouldBe  "foo"
@@ -511,7 +514,7 @@ class MappingConverterParameterSpec: StringSpec({
         annotationMappings[1].annotation.type shouldBe "io.openapiprocessor.Bar"
 
         val annotationMappingsGet = mappings["/foo"]!!.findAnnotationParameterNameTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, name = "foo"))
+            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, name = "foo"), ParametersStep())
 
         annotationMappingsGet shouldHaveSize 2
         annotationMappingsGet[0].name shouldBe  "foo"
@@ -547,7 +550,7 @@ class MappingConverterParameterSpec: StringSpec({
 
         // then:
         val addMappings = mappings["/foo"]!!.findAddParameterTypeMappings(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST))
+            MappingFinderQuery(path = "/foo", method = HttpMethod.POST), ParametersStep())
 
         addMappings shouldHaveSize 2
         addMappings[0].parameterName shouldBe "foo"
@@ -556,7 +559,7 @@ class MappingConverterParameterSpec: StringSpec({
         addMappings[1].mapping.targetTypeName shouldBe "io.openapiprocessor.Bar"
 
         val addMappingsGet = mappings["/foo"]!!.findAddParameterTypeMappings(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET))
+            MappingFinderQuery(path = "/foo", method = HttpMethod.GET), ParametersStep())
 
         addMappingsGet shouldHaveSize 2
         addMappingsGet[0].parameterName shouldBe "foo2"
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterResponseSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterResponseSpec.kt
index 7b44ba06b..7040df6ce 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterResponseSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterResponseSpec.kt
@@ -13,6 +13,7 @@ import io.kotest.matchers.shouldBe
 import io.mockk.mockk
 import io.openapiprocessor.core.converter.MappingFinderQuery
 import io.openapiprocessor.core.converter.mapping.AmbiguousTypeMappingException
+import io.openapiprocessor.core.converter.mapping.steps.ContentTypesStep
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.processor.MappingReader
 import io.openapiprocessor.core.support.responseTypeMatcher
@@ -36,7 +37,7 @@ class MappingConverterResponseSpec: StringSpec({
 
         // then:
         val contentMapping = mappings.findContentTypeMapping(
-            responseTypeMatcher(contentType = "application/vnd.array"))!!
+            responseTypeMatcher(contentType = "application/vnd.array"), ContentTypesStep())!!
 
         contentMapping.contentType shouldBe "application/vnd.array"
         contentMapping.mapping.sourceTypeName.shouldBeNull()
@@ -60,7 +61,7 @@ class MappingConverterResponseSpec: StringSpec({
 
         // then:
         val contentMapping = mappings.findContentTypeMapping(
-            responseTypeMatcher(contentType = "application/vnd.array"))
+            responseTypeMatcher(contentType = "application/vnd.array"), ContentTypesStep())
 
         contentMapping.shouldBeNull()
     }
@@ -84,8 +85,7 @@ class MappingConverterResponseSpec: StringSpec({
 
         shouldThrow<AmbiguousTypeMappingException> {
             mappings.findContentTypeMapping(
-                responseTypeMatcher(contentType = "application/vnd.array")
-            )
+                responseTypeMatcher(contentType = "application/vnd.array"), ContentTypesStep())
         }
     }
 
@@ -113,8 +113,8 @@ class MappingConverterResponseSpec: StringSpec({
         val mappings = MappingConverter(mapping).convert().endpointMappings
 
         // then:
-        val contentMapping = mappings["/foo"]!!.findContentTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, contentType = "application/vnd.array"))!!
+        val query = MappingFinderQuery(path = "/foo", method = HttpMethod.POST, contentType = "application/vnd.array")
+        val contentMapping = mappings["/foo"]!!.findContentTypeMapping(query, ContentTypesStep())!!
 
         contentMapping.contentType shouldBe "application/vnd.array"
         contentMapping.mapping.sourceTypeName.shouldBeNull()
@@ -122,8 +122,8 @@ class MappingConverterResponseSpec: StringSpec({
         contentMapping.mapping.targetTypeName shouldBe "java.util.List"
         contentMapping.mapping.genericTypes.shouldBeEmpty()
 
-        val contentMappingGet = mappings["/foo"]!!.findContentTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, contentType = "application/vnd.array"))!!
+        val queryGet = MappingFinderQuery(path = "/foo", method = HttpMethod.GET, contentType = "application/vnd.array")
+        val contentMappingGet = mappings["/foo"]!!.findContentTypeMapping(queryGet, ContentTypesStep())!!
 
         contentMappingGet.contentType shouldBe "application/vnd.array"
         contentMappingGet.mapping.sourceTypeName.shouldBeNull()
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterSpec.kt
index 6cc9b1404..741d75e0a 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterSpec.kt
@@ -16,6 +16,8 @@ import io.kotest.matchers.nulls.shouldNotBeNull
 import io.kotest.matchers.shouldBe
 import io.mockk.mockk
 import io.openapiprocessor.core.converter.MappingFinderQuery
+import io.openapiprocessor.core.converter.mapping.steps.ParametersStep
+import io.openapiprocessor.core.converter.mapping.steps.TypesStep
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.processor.MappingReader
 import io.openapiprocessor.core.support.annotationTypeMatcher
@@ -42,7 +44,7 @@ class MappingConverterSpec: StringSpec({
 
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().globalMappings
 
-        val mapping = mappings.findTypeMapping(typeMatcher(path = "/foo", name = "Foo"))
+        val mapping = mappings.findTypeMapping(typeMatcher(path = "/foo", name = "Foo"), TypesStep())
         mapping!!.sourceTypeName shouldBe "Foo"
         mapping.sourceTypeFormat.shouldBeNull()
         mapping.targetTypeName shouldBe "io.openapiprocessor.Foo"
@@ -126,9 +128,10 @@ class MappingConverterSpec: StringSpec({
 
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().globalMappings
 
-        val annotations = mappings.findAnnotationParameterTypeMapping(annotationTypeMatcher(name = "Foo"))
-        annotations shouldHaveSize 1
+        val annotations = mappings.findAnnotationParameterTypeMapping(
+            annotationTypeMatcher(name = "Foo"), ParametersStep())
 
+        annotations shouldHaveSize 1
         val annotation = annotations.first()
         annotation.sourceTypeName shouldBe "Foo"
         annotation.sourceTypeFormat.shouldBeNull()
@@ -150,7 +153,8 @@ class MappingConverterSpec: StringSpec({
                    """.trimMargin()
 
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().endpointMappings
-        val annotations = mappings["/foo"]!!.findAnnotationParameterTypeMapping(MappingFinderQuery(name = "Foo"))
+        val annotations = mappings["/foo"]!!.findAnnotationParameterTypeMapping(
+            MappingFinderQuery(name = "Foo"), ParametersStep())
 
         annotations shouldHaveSize 1
 
@@ -177,7 +181,7 @@ class MappingConverterSpec: StringSpec({
 
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().endpointMappings
         val annotations = mappings["/foo"]!!.findAnnotationParameterTypeMapping(
-            MappingFinderQuery(name = "Foo", method = HttpMethod.GET))
+            MappingFinderQuery(name = "Foo", method = HttpMethod.GET), ParametersStep())
 
         annotations shouldHaveSize 1
 
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterTypeSpec.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterTypeSpec.kt
index 4225771f2..600aef896 100644
--- a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterTypeSpec.kt
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/processor/mapping/v2/MappingConverterTypeSpec.kt
@@ -12,6 +12,8 @@ import io.kotest.matchers.shouldBe
 import io.openapiprocessor.core.converter.MappingFinderQuery
 import io.openapiprocessor.core.converter.mapping.*
 import io.openapiprocessor.core.converter.mapping.matcher.AnnotationTypeMatcher
+import io.openapiprocessor.core.converter.mapping.steps.RootStep
+import io.openapiprocessor.core.converter.mapping.steps.TypesStep
 import io.openapiprocessor.core.parser.HttpMethod
 import io.openapiprocessor.core.processor.MappingReader
 import io.openapiprocessor.core.support.query
@@ -181,13 +183,12 @@ class MappingConverterTypeSpec: FreeSpec({
             val yaml = buildMapping(source, generics)
 
             // when:
-            val mapping = reader.read (yaml) as Mapping
             val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().globalMappings
 
             // then:
             val typeMapping = mappings.findTypeMapping(
-                typeMatcher(name = expected.sourceTypeName, format = expected.sourceTypeFormat)
-            )!!
+                typeMatcher(name = expected.sourceTypeName, format = expected.sourceTypeFormat),
+                TypesStep())!!
 
             typeMapping.sourceTypeName shouldBe expected.sourceTypeName
             typeMapping.sourceTypeFormat shouldBe expected.sourceTypeFormat
@@ -212,11 +213,10 @@ class MappingConverterTypeSpec: FreeSpec({
            """.trimMargin()
 
         // when:
-        val mapping = reader.read (yaml) as Mapping
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().globalMappings
 
         // then:
-        val typeMapping = mappings.findTypeMapping(typeMatcher(name = "Foo"))
+        val typeMapping = mappings.findTypeMapping(typeMatcher(name = "Foo"), TypesStep())
 
         typeMapping.shouldBeNull()
     }
@@ -234,11 +234,10 @@ class MappingConverterTypeSpec: FreeSpec({
            |    - type: Foo => io.openapiprocessor.Foo
            """.trimMargin()
 
-        val mapping = reader.read (yaml) as Mapping
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().globalMappings
 
         shouldThrow<AmbiguousTypeMappingException> {
-            mappings.findTypeMapping(typeMatcher(name = "Foo"))
+            mappings.findTypeMapping(typeMatcher(name = "Foo"), TypesStep())
         }
     }
 
@@ -259,7 +258,7 @@ class MappingConverterTypeSpec: FreeSpec({
         val mappings = MappingConverter(mapping).convert()
 
         val annotationMappings = mappings.globalMappings.findAnnotationTypeMapping(
-            AnnotationTypeMatcher(MappingFinderQuery(type = "Foo")))
+            AnnotationTypeMatcher(MappingFinderQuery(type = "Foo")), TypesStep())
 
         annotationMappings shouldHaveSize 1
         val annotationMapping = annotationMappings.first()
@@ -287,7 +286,7 @@ class MappingConverterTypeSpec: FreeSpec({
         val mappings = MappingConverter(mapping).convert()
 
         val annotationMappings = mappings.globalMappings.findAnnotationTypeMapping(
-            AnnotationTypeMatcher(MappingFinderQuery(type = "Foo", allowObject = true)))
+            AnnotationTypeMatcher(MappingFinderQuery(type = "Foo", allowObject = true)), TypesStep())
 
         annotationMappings shouldHaveSize 3
     }
@@ -302,12 +301,11 @@ class MappingConverterTypeSpec: FreeSpec({
            """.trimMargin()
 
         // when:
-        val mapping = reader.read (yaml) as Mapping
         val mappings = MappingConverter(reader.read(yaml) as Mapping).convert().globalMappings
 
-
         // then:
-        val annotationMappings = mappings.findAnnotationTypeMapping(AnnotationTypeMatcher(MappingFinderQuery(name = "Foo")))
+        val annotationMappings = mappings.findAnnotationTypeMapping(
+            AnnotationTypeMatcher(MappingFinderQuery(name = "Foo")), TypesStep())
 
         annotationMappings.shouldBeEmpty()
     }
@@ -339,14 +337,14 @@ class MappingConverterTypeSpec: FreeSpec({
 
         // then:
         val typeMapping = epMappings?.findTypeMapping(
-            query(path = "/foo", method = HttpMethod.POST, name = "Foo"))!!
+            query(path = "/foo", method = HttpMethod.POST, name = "Foo"), TypesStep())!!
 
         typeMapping.sourceTypeName shouldBe "Foo"
         typeMapping.sourceTypeFormat.shouldBeNull()
         typeMapping.targetTypeName shouldBe "io.openapiprocessor.Foo"
 
         val typeMappingGet = epMappings.findTypeMapping(
-            query(path = "/foo", method = HttpMethod.GET, name = "Foo"))!!
+            query(path = "/foo", method = HttpMethod.GET, name = "Foo"), TypesStep())!!
 
         typeMappingGet.sourceTypeName shouldBe "Foo"
         typeMappingGet.sourceTypeFormat.shouldBeNull()
@@ -376,9 +374,8 @@ class MappingConverterTypeSpec: FreeSpec({
         val mappings = MappingConverter(mapping).convert()
         val repository = MappingRepository(endpointMappings = mappings.endpointMappings)
 
-        val annotationMappings = repository.findEndpointAnnotationTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.POST, type = "Foo")
-        )
+        val query = MappingFinderQuery(path = "/foo", method = HttpMethod.POST, type = "Foo")
+        val annotationMappings = repository.findEndpointAnnotationTypeMapping(query, RootStep("", query))
 
         annotationMappings shouldHaveSize 1
         val annotationMapping = annotationMappings.first()
@@ -387,9 +384,8 @@ class MappingConverterTypeSpec: FreeSpec({
         annotationMapping.annotation.type shouldBe "io.openapiprocessor.Foo"
         annotationMapping.annotation.parameters.shouldBeEmpty()
 
-        val annotationMappingsGet = repository.findEndpointAnnotationTypeMapping(
-            MappingFinderQuery(path = "/foo", method = HttpMethod.GET, type = "Foo")
-        )
+        val queryGet = MappingFinderQuery(path = "/foo", method = HttpMethod.GET, type = "Foo")
+        val annotationMappingsGet = repository.findEndpointAnnotationTypeMapping(queryGet, RootStep("", queryGet))
 
         annotationMappingsGet shouldHaveSize 1
         val annotationMappingGet = annotationMappingsGet.first()
diff --git a/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/support/AnyMatcher.kt b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/support/AnyMatcher.kt
new file mode 100644
index 000000000..fa0d39b06
--- /dev/null
+++ b/openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/support/AnyMatcher.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 https://github.com/openapi-processor/openapi-processor-base
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.support
+
+import io.openapiprocessor.core.converter.mapping.Mapping
+import io.openapiprocessor.core.converter.mapping.MappingMatcher
+import io.openapiprocessor.core.converter.mapping.steps.MappingStep
+import io.openapiprocessor.core.converter.mapping.steps.MatcherStep
+
+class AnyMatcher: MappingMatcher {
+
+    override fun match(mapping: Mapping, step: MappingStep): Boolean {
+        step.add(MatcherStep(mapping, true))
+        return true;
+    }
+}
diff --git a/openapi-processor-core/src/testInt/resources/logback-test.xml b/openapi-processor-core/src/testInt/resources/logback-test.xml
index 4d8cb017e..2fb9902d7 100644
--- a/openapi-processor-core/src/testInt/resources/logback-test.xml
+++ b/openapi-processor-core/src/testInt/resources/logback-test.xml
@@ -6,10 +6,21 @@
     </encoder>
   </appender>
 
+  <appender name="io.openapiprocessor.mapping" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%msg%n</pattern>
+    </encoder>
+  </appender>
+
   <root level="info">
     <appender-ref ref="STDOUT" />
   </root>
 
   <logger name="io.openapiprocessor.core.parser.OpenApiParser" level="WARN" />
   <logger name="io.openapiprocessor.core.processor.MappingReader" level="ERROR" />
+
+  <logger name="io.openapiprocessor.core.converter.mapping" level="TRACE" additivity="false">
+    <appender-ref ref="io.openapiprocessor.mapping" />
+  </logger>
+
 </configuration>