Create Logger, replace existing logging

src/main/java/io/beanmapper/config/OverrideField.java

@@ -2,6 +2,8 @@
 
 import java.util.function.Supplier;
 
+import io.beanmapper.utils.BeanMapperPerformanceLogger;
+
 public class OverrideField<T> {
 
     private final Supplier<T> supplier;
@@ -31,9 +33,10 @@ public T get() {
         if (this.block) {
             return null;
         }
-        return this.value == null ?
-                this.supplier.get() :
-                this.value;
+        if (this.value == null) {
+            this.value = BeanMapperPerformanceLogger.runTimedTask("Retrieving nested configuration field.", this.supplier);
+        }
+        return value;
     }
 
-}
+}

src/main/java/io/beanmapper/config/StrictMappingProperties.java

@@ -2,6 +2,7 @@
 
 import io.beanmapper.core.unproxy.BeanUnproxy;
 import io.beanmapper.core.unproxy.SkippingBeanUnproxy;
+import io.beanmapper.utils.BeanMapperPerformanceLogger;
 
 public class StrictMappingProperties {
 
@@ -79,18 +80,20 @@ public void setApplyStrictMappingConvention(boolean applyStrictMappingConvention
     }
 
     public BeanPair createBeanPair(Class<?> sourceClass, Class<?> targetClass) {
-        sourceClass = beanUnproxy.unproxy(sourceClass);
-        targetClass = beanUnproxy.unproxy(targetClass);
-        BeanPair beanPair = new BeanPair(sourceClass, targetClass);
+        BeanPair beanPair = BeanMapperPerformanceLogger.runTimedTask("Creating BeanPair, and unproxying source %s-class and target %s-class.".formatted(sourceClass.getCanonicalName(), targetClass.getCanonicalName()), () -> {
+            Class<?> unproxiedSource = beanUnproxy.unproxy(sourceClass);
+            Class<?> unproxiedTarget = beanUnproxy.unproxy(targetClass);
+            return new BeanPair(unproxiedSource, unproxiedTarget);
+        });
         if (!isApplyStrictMappingConvention()) {
             return beanPair;
         }
         if (strictSourceSuffix != null &&
-                sourceClass.getCanonicalName().endsWith(strictSourceSuffix)) {
+            beanPair.getSourceClass().getCanonicalName().endsWith(strictSourceSuffix)) {
             beanPair = beanPair.withStrictSource();
         }
         if (strictTargetSuffix != null &&
-                targetClass.getCanonicalName().endsWith(strictTargetSuffix)) {
+            beanPair.getTargetClass().getCanonicalName().endsWith(strictTargetSuffix)) {
             beanPair = beanPair.withStrictTarget();
         }
         return beanPair;

src/main/java/io/beanmapper/core/BeanMatch.java

@@ -8,8 +8,13 @@
 import io.beanmapper.config.BeanPair;
 import io.beanmapper.exceptions.BeanNoSuchPropertyException;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 public class BeanMatch {
 
+    private static final Logger log = LoggerFactory.getLogger(BeanMatch.class);
+
     private final BeanPair beanPair;
 
     private final Map<String, BeanProperty> sourceNodes;
@@ -106,6 +111,7 @@ private void checkForMandatoryUnmatchedNodes(String side, Class<?> containingCla
         for (Map.Entry<String, BeanProperty> entry : nodes.entrySet()) {
             BeanProperty currentField = entry.getValue();
             if (currentField.isUnmatched()) {
+                log.error("{} {} has no match for property {}", side, containingClass.isAnonymousClass(), entry.getKey());
                 throw new BeanNoSuchPropertyException(side + " " + containingClass.getCanonicalName() + " has no match for property " + entry.getKey());
             }
         }

src/main/java/io/beanmapper/core/BeanMatchStore.java

@@ -34,15 +34,11 @@
 import io.beanmapper.exceptions.BeanMissingPathException;
 import io.beanmapper.exceptions.BeanNoSuchPropertyException;
 import io.beanmapper.exceptions.FieldShadowingException;
+import io.beanmapper.utils.BeanMapperTraceLogger;
 import io.beanmapper.utils.Trinary;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class BeanMatchStore {
 
-    private final Logger logger = LoggerFactory.getLogger(getClass());
-
     private final CollectionHandlerStore collectionHandlerStore;
 
     private final BeanUnproxy beanUnproxy;
@@ -287,11 +283,11 @@ private BeanPropertyWrapper dealWithBeanProperty(BeanPropertyMatchupDirection ma
                         new BeanPropertyCreator(matchupDirection.getInverse(), otherType, wrapper.getName())
                                 .determineNodesForPath());
             } catch (BeanNoSuchPropertyException err) {
-                if (logger.isDebugEnabled()) {
-                    logger.debug("""
+
+                    BeanMapperTraceLogger.log("""
                             BeanNoSuchPropertyException thrown by BeanMatchStore#dealWithBeanProperty(BeanPropertyMatchupDirection, Map<String, BeanProperty>, Class, PropertyAccessor), for {}.
                             {}""", wrapper.getName(), err.getMessage());
-                }
+
             }
         }
         return wrapper;

src/main/java/io/beanmapper/core/BeanPropertyCreator.java

@@ -6,8 +6,13 @@
 import io.beanmapper.core.inspector.PropertyAccessors;
 import io.beanmapper.exceptions.BeanNoSuchPropertyException;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 public class BeanPropertyCreator {
 
+    private static final Logger log = LoggerFactory.getLogger(BeanPropertyCreator.class);
+
     private final BeanPropertyMatchupDirection matchupDirection;
 
     private final Class<?> baseClass;
@@ -68,6 +73,7 @@ private void traversePath(Stack<BeanProperty> beanProperties) {
         for (String node : route.getRoute()) {
             final PropertyAccessor property = PropertyAccessors.findProperty(currentBaseClass, node);
             if (property == null) {
+                log.error("Property '{}' does not exist in: {}", node, currentBaseClass.getSimpleName());
                 throw new BeanNoSuchPropertyException("Property '" + node + "' does not exist in: " + currentBaseClass.getSimpleName());
             }
             beanProperties.push(new BeanProperty(

src/main/java/io/beanmapper/core/BeanPropertyMatch.java

@@ -10,13 +10,14 @@
 import io.beanmapper.exceptions.BeanMappingException;
 import io.beanmapper.exceptions.BeanNoLogicSecuredCheckSetException;
 import io.beanmapper.exceptions.BeanNoRoleSecuredCheckSetException;
+import io.beanmapper.utils.BeanMapperTraceLogger;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class BeanPropertyMatch {
 
-    protected final Logger logger = LoggerFactory.getLogger(getClass());
+    private static final Logger log = LoggerFactory.getLogger(BeanPropertyMatch.class);
 
     private final BeanMatch beanMatch;
     private final Object source;
@@ -81,7 +82,7 @@
             if (enforcedSecuredProperties) {
                 throw new BeanNoLogicSecuredCheckSetException(message);
             }
-            logger.warn(message);
+            BeanMapperTraceLogger.log(message);
             return true;
         }
         return logicSecuredCheck.isAllowed(source, target);
@@ -96,7 +97,7 @@
             if (enforcedSecuredProperties) {
                 throw new BeanNoRoleSecuredCheckSetException(message);
             }
-            logger.warn(message);
+            log.warn(message);
         }
     }
 

src/main/java/io/beanmapper/core/BeanStrictMappingRequirementsException.java

@@ -3,13 +3,14 @@
 import java.util.Collections;
 import java.util.List;
 
+import io.beanmapper.utils.BeanMapperTraceLogger;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class BeanStrictMappingRequirementsException extends RuntimeException {
 
-    protected final transient Logger logger = LoggerFactory.getLogger(getClass());
-
+    private static final Logger log = LoggerFactory.getLogger(BeanStrictMappingRequirementsException.class);
     private final List<BeanMatchValidationMessage> validationMessages;
 
     public BeanStrictMappingRequirementsException(BeanMatchValidationMessage validationMessage) {
@@ -26,7 +27,7 @@ private void logErrors(List<BeanMatchValidationMessage> validationMessages) {
             if (validationMessage.isLogged()) {
                 continue;
             }
-            logger.error("""
+            log.error("""
                             Missing matching properties for source [{}] {} > target [{}] {} for fields:
                             """,
                     validationMessage.getSourceClass().getCanonicalName(),
@@ -35,7 +36,7 @@ private void logErrors(List<BeanMatchValidationMessage> validationMessages) {
                     (validationMessage.isTargetStrict() ? "*" : ""));
 
             for (BeanProperty field : validationMessage.getFields()) {
-                logger.error("""
+                log.error("""
                                 > {}.{}
                                 """,
                         validationMessage.getStrictClass().getSimpleName(),

src/main/java/io/beanmapper/core/collections/AbstractCollectionHandler.java

@@ -5,6 +5,7 @@
 import io.beanmapper.config.CollectionFlusher;
 import io.beanmapper.core.constructor.DefaultBeanInitializer;
 import io.beanmapper.exceptions.BeanCollectionUnassignableTargetCollectionTypeException;
+import io.beanmapper.utils.BeanMapperPerformanceLogger;
 import io.beanmapper.utils.Classes;
 
 public abstract class AbstractCollectionHandler<C> implements CollectionHandler<C> {
@@ -32,14 +33,16 @@ public Object mapItem(
             BeanMapper beanMapper,
             Class<?> collectionElementClass,
             Object source) {
-
-        return beanMapper
-                .wrap()
+        return BeanMapperPerformanceLogger.runTimedTask("Recursively calling BeanMapper#map(Object), to map collection elements of type %s, to %s."
+                .formatted(source != null
+                        ? source.getClass().getCanonicalName()
+                        : "null", collectionElementClass.getCanonicalName()),
+                () -> beanMapper.wrap()
                 .setTargetClass(collectionElementClass)
                 .setCollectionClass(null)
                 .setConverterChoosable(true)
                 .build()
-                .map(source);
+                .map(source));
     }
 
     @Override
@@ -90,4 +93,4 @@ public int getGenericParameterIndex() {
         return 0;
     }
 
-}
+}

src/main/java/io/beanmapper/core/constructor/DefaultBeanInitializer.java

@@ -12,20 +12,22 @@
 import io.beanmapper.BeanMapper;
 import io.beanmapper.config.BeanMapperBuilder;
 import io.beanmapper.strategy.ConstructorArguments;
+import io.beanmapper.utils.BeanMapperTraceLogger;
 import io.beanmapper.utils.DefaultValues;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class DefaultBeanInitializer implements BeanInitializer {
 
-    private final Logger logger = LoggerFactory.getLogger(getClass());
+    private static final Logger log = LoggerFactory.getLogger(DefaultBeanInitializer.class);
 
     /**
      * {@inheritDoc}
      */
     @Override
     public <T> T instantiate(Class<T> beanClass, ConstructorArguments arguments) {
+        BeanMapperTraceLogger.log("Creating a new instance of type %s, using reflection.".formatted(beanClass));
         try {
             if (arguments == null) {
                 return beanClass.getConstructor().newInstance();
@@ -34,7 +36,7 @@
             var constructorParameterTypes = Arrays.stream(constructor.getParameters()).map(Parameter::getParameterizedType).toArray(Type[]::new);
             return beanClass.getConstructor(arguments.getTypes()).newInstance(mapParameterizedArguments(constructorParameterTypes, arguments.getValues()));
         } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
-            logger.error("Could not instantiate bean of class %s. Returning the default value associated with the given type. %s".formatted(beanClass.getName(),
+            log.error("Could not instantiate bean of class %s. Returning the default value associated with the given type. %s".formatted(beanClass.getName(),
                     e.getMessage()));
             return DefaultValues.defaultValueFor(beanClass);
         }

src/main/java/io/beanmapper/core/converter/collections/CollectionConverter.java

@@ -4,6 +4,7 @@
 import io.beanmapper.core.BeanPropertyMatch;
 import io.beanmapper.core.collections.CollectionHandler;
 import io.beanmapper.core.converter.BeanConverter;
+import io.beanmapper.utils.BeanMapperPerformanceLogger;
 
 public class CollectionConverter implements BeanConverter {
 
@@ -24,7 +25,11 @@ public <R, U> U convert(
             return targetClass.cast(source);
         }
 
-        return beanMapper.wrap()
+        return BeanMapperPerformanceLogger.runTimedTask("Calling BeanMapper#map(Object) recursively, to convert object of type %s, to type %s."
+                .formatted(source != null
+                        ? source.getClass().getCanonicalName()
+                        : "null", targetClass.getCanonicalName()),
+                () -> beanMapper.wrap()
                 .setCollectionClass(collectionHandler.getType())
                 .setCollectionUsage(beanPropertyMatch.getCollectionInstructions().getBeanCollectionUsage())
                 .setPreferredCollectionClass(beanPropertyMatch.getCollectionInstructions().getPreferredCollectionClass().getAnnotationClass())
@@ -33,7 +38,7 @@ public <R, U> U convert(
                 .setTarget(beanPropertyMatch.getTargetObject())
                 .setUseNullValue()
                 .build()
-                .map(source);
+                .map(source));
     }
 
     @Override

src/main/java/io/beanmapper/core/converter/impl/ObjectToOptionalConverter.java

@@ -10,6 +10,9 @@
 import io.beanmapper.core.converter.BeanConverter;
 import io.beanmapper.exceptions.BeanNoSuchPropertyException;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * This converter facilitates the conversion of an object to an Optional wrapping another object. This converter does
  * not support the conversion of complex datastructures, such as Collections, to Optionals. If that functionality is
@@ -18,6 +21,8 @@
  */
 public class ObjectToOptionalConverter implements BeanConverter {
 
+    private static final Logger log = LoggerFactory.getLogger(ObjectToOptionalConverter.class);
+
     @Override
     public <S, T> T convert(BeanMapper beanMapper, S source, Class<T> targetClass, BeanPropertyMatch beanPropertyMatch) {
         if (source == null) {
@@ -28,6 +33,7 @@
         try {
             targetField = beanPropertyMatch.getTarget().getClass().getDeclaredField(beanPropertyMatch.getTargetFieldName());
         } catch (NoSuchFieldException e) {
+            log.error(e.getMessage());
             throw new BeanNoSuchPropertyException(e.getMessage());
         }
 

src/main/java/io/beanmapper/core/converter/impl/OptionalToObjectConverter.java

@@ -12,11 +12,9 @@
 import io.beanmapper.BeanMapper;
 import io.beanmapper.core.BeanPropertyMatch;
 import io.beanmapper.core.converter.BeanConverter;
+import io.beanmapper.utils.BeanMapperTraceLogger;
 import io.beanmapper.utils.Classes;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /**
  * This converter facilitates the conversion of an arbitrary amount of Optional wrappers, however, support for complex
  * datastructures, such as Maps, Sets, List, etc. is limited to a single layer. As such, if the user requires support
@@ -25,8 +23,6 @@
  */
 public class OptionalToObjectConverter implements BeanConverter {
 
-    private final Logger logger = LoggerFactory.getLogger(this.getClass());
-
     /**
      * {@inheritDoc}
      */
@@ -35,13 +31,11 @@ public <S, T> T convert(BeanMapper beanMapper, S source, Class<T> targetClass, B
         Object obj = ((Optional<?>) source).orElse(null);
 
         if (targetClass.equals(Optional.class)) {
-            if (logger.isDebugEnabled()) {
-                // Not always possible to get the actual source class, so just report the name of the field. Debug log will show the call stack.
-                logger.debug("Converting Optional to Optional. Perhaps the target does not need to be an Optional?\nSource-field: {}\nTarget: {}.{}",
-                        beanPropertyMatch.getSourceFieldName(),
-                        beanPropertyMatch.getTarget().getClass(),
-                        beanPropertyMatch.getTargetFieldName());
-            }
+            // Not always possible to get the actual source class, so just report the name of the field. Debug log will show the call stack.
+            BeanMapperTraceLogger.log("Converting Optional to Optional. Perhaps the target does not need to be an Optional?\nSource-field: {}\nTarget: {}.{}",
+                    beanPropertyMatch.getSourceFieldName(),
+                    beanPropertyMatch.getTarget().getClass(),
+                    beanPropertyMatch.getTargetFieldName());
             return targetClass.cast(convertToOptional(beanMapper, (Optional<?>) source, beanPropertyMatch));
         } else if (obj == null) {
             return null;

src/main/java/io/beanmapper/core/unproxy/SkippingBeanUnproxy.java

@@ -6,6 +6,8 @@
 import java.util.HashSet;
 import java.util.Set;
 
+import io.beanmapper.utils.BeanMapperTraceLogger;
+
 /**
  * Unproxy that allows you to configure classes to skip.
  *
@@ -31,6 +33,7 @@ public SkippingBeanUnproxy(BeanUnproxy delegate) {
      */
     @Override
     public Class<?> unproxy(Class<?> beanClass) {
+        BeanMapperTraceLogger.log("Unproxying class %s.".formatted(beanClass != null ? beanClass.getCanonicalName() : "null"));
         if (isSkippedProxyClass(beanClass)) {
             return beanClass;
         }