Skip to content

clean up logging related to bytecode enhancement #10931

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 7 commits into from
Sep 12, 2025
+634 −277
Merged

clean up logging related to bytecode enhancement #10931

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
5a00177
clean up logging related to bytecode enhancement
gavinking Sep 12, 2025
69de8a5
centralize logging in org.hibernate.resource.jdbc.internal
gavinking Sep 12, 2025
7dda59a
more use of typesafe methods for logging
gavinking Sep 12, 2025
005e0a6
introduce SynchronizationLogging
gavinking Sep 12, 2025
a0c3b64
delete commented code
gavinking Sep 12, 2025
696fa18
more typesafe logging
gavinking Sep 12, 2025
88b7d90
fix message id range
gavinking Sep 12, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 0 additions & 23 deletions hibernate-core/src/main/java/org/hibernate/bytecode/BytecodeLogging.java
View file
Open in desktop

This file was deleted.

112 changes: 112 additions & 0 deletions ...ore/src/main/java/org/hibernate/bytecode/enhance/internal/BytecodeEnhancementLogging.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,112 @@
/*
* SPDX-License-Identifier: Apache-2.0
* Copyright Red Hat Inc. and Hibernate Authors
*/
package org.hibernate.bytecode.enhance.internal;

import org.hibernate.Internal;
import org.hibernate.internal.log.SubSystemLogging;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
import org.jboss.logging.annotations.ValidIdRange;

import java.lang.invoke.MethodHandles;

import static org.jboss.logging.Logger.Level.DEBUG;
import static org.jboss.logging.Logger.Level.INFO;
import static org.jboss.logging.Logger.Level.TRACE;


/**
* @author Steve Ebersole
*/
@MessageLogger(projectCode = "HHH")
@ValidIdRange(min = 90009001, max = 90009900)
@SubSystemLogging(
name = BytecodeEnhancementLogging.LOGGER_NAME,
description = "Logging related to bytecode handling"
)
@Internal
public interface BytecodeEnhancementLogging extends BasicLogger {
String LOGGER_NAME = SubSystemLogging.BASE + ".bytecode.enhancement";
BytecodeEnhancementLogging LOGGER = Logger.getMessageLogger( MethodHandles.lookup(), BytecodeEnhancementLogging.class, LOGGER_NAME );

// ---- trace messages ----
@LogMessage(level = TRACE)
@Message(id = 90009001, value = "Skipping enhancement of [%s]: it's already annotated with @EnhancementInfo")
void skippingAlreadyAnnotated(String className);

@LogMessage(level = TRACE)
@Message(id = 90009002, value = "Skipping enhancement of [%s]: it's an interface")
void skippingInterface(String className);

@LogMessage(level = TRACE)
@Message(id = 90009003, value = "Skipping enhancement of [%s]: it's a record")
void skippingRecord(String className);

@LogMessage(level = TRACE)
@Message(id = 90009004, value = "Enhancing [%s] as Entity")
void enhancingAsEntity(String className);

@LogMessage(level = TRACE)
@Message(id = 90009005, value = "Enhancing [%s] as Composite")
void enhancingAsComposite(String className);

@LogMessage(level = TRACE)
@Message(id = 90009006, value = "Enhancing [%s] as MappedSuperclass")
void enhancingAsMappedSuperclass(String className);

@LogMessage(level = TRACE)
@Message(id = 90009007, value = "Extended enhancement of [%s]")
void extendedEnhancement(String className);

@LogMessage(level = TRACE)
@Message(id = 90009008, value = "Skipping enhancement of [%s]: not entity or composite")
void skippingNotEntityOrComposite(String className);

@LogMessage(level = TRACE)
@Message(id = 90009009, value = "Weaving in PersistentAttributeInterceptable implementation on [%s]")
void weavingPersistentAttributeInterceptable(String className);

@LogMessage(level = TRACE)
@Message(id = 90009010, value = "mappedBy association for field [%s.%s] is [%s.%s]")
void mappedByAssociation(String ownerName, String fieldName, String targetEntityName, String targetFieldName);

@LogMessage(level = TRACE)
@Message(id = 90009011, value = "Persistent fields for entity %s: %s")
void persistentFieldsForEntity(String entityName, String orderedFields);

@LogMessage(level = TRACE)
@Message(id = 90009012, value = "Found @MappedSuperclass '%s' to collectPersistenceFields")
void foundMappedSuperclass(String superClassName);

@LogMessage(level = TRACE)
@Message(id = 90009013, value = "Extended enhancement: Transforming access to field [%s.%s] from method [%s.%s()]")
void extendedTransformingFieldAccess(String ownerType, String fieldName, String methodOwner, String methodName);

// ---- debug messages ----
@LogMessage(level = DEBUG)
@Message(id = 90009020, value = "Skipping re-enhancement version check for '%s' due to 'ignore'")
void skippingReEnhancementVersionCheck(String className);

@LogMessage(level = DEBUG)
@Message(id = 90009021, value = "Skipping enhancement of [%s] because no field named [%s] could be found for property accessor method [%s]."
+ " To fix this, make sure all property accessor methods have a matching field.")
void propertyAccessorNoFieldSkip(String className, String fieldName, String methodName);

// ---- info messages ----
@LogMessage(level = INFO)
@Message(id = 90009030, value = "Bidirectional association not managed for field [%s.%s]: Could not find target field in [%s]")
void bidirectionalNotManagedCouldNotFindTargetField(String ownerName, String fieldName, String targetEntityCanonicalName);

@LogMessage(level = INFO)
@Message(id = 90009031, value = "Bidirectional association not managed for field [%s.%s]: @ManyToMany in java.util.Map attribute not supported ")
void manyToManyInMapNotSupported(String ownerName, String fieldName);

@LogMessage(level = INFO)
@Message(id = 90009032, value = "Bidirectional association not managed for field [%s.%s]: Could not find target type")
void bidirectionalNotManagedCouldNotFindTargetType(String ownerName, String fieldName);
}
41 changes: 15 additions & 26 deletions ...va/org/hibernate/bytecode/enhance/internal/bytebuddy/BiDirectionalAssociationHandler.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,8 +20,7 @@
import org.hibernate.bytecode.enhance.internal.bytebuddy.EnhancerImpl.AnnotatedFieldDescription;
import org.hibernate.bytecode.enhance.spi.EnhancementException;
import org.hibernate.bytecode.enhance.spi.EnhancerConstants;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.bytecode.enhance.internal.BytecodeEnhancementLogging;

import net.bytebuddy.asm.Advice;
import net.bytebuddy.description.annotation.AnnotationDescription;
Expand All @@ -40,8 +39,6 @@

final class BiDirectionalAssociationHandler implements Implementation {

private static final CoreMessageLogger LOG = CoreLogging.messageLogger( BiDirectionalAssociationHandler.class );

static Implementation wrap(
TypeDescription managedCtClass,
ByteBuddyEnhancementContext enhancementContext,
Expand All @@ -64,9 +61,8 @@ static Implementation wrap(
bidirectionalAttributeName = mappedBy;
}
if ( bidirectionalAttributeName == null || bidirectionalAttributeName.isEmpty() ) {
if ( LOG.isInfoEnabled() ) {
LOG.infof(
"Bidirectional association not managed for field [%s#%s]: Could not find target field in [%s]",
if ( BytecodeEnhancementLogging.LOGGER.isInfoEnabled() ) {
BytecodeEnhancementLogging.LOGGER.bidirectionalNotManagedCouldNotFindTargetField(
managedCtClass.getName(),
persistentField.getName(),
targetEntity.getCanonicalName()
Expand Down Expand Up @@ -120,9 +116,8 @@ static Implementation wrap(
if ( persistentField.hasAnnotation( ManyToMany.class ) ) {

if ( persistentField.getType().asErasure().isAssignableTo( Map.class ) || targetType.isAssignableTo( Map.class ) ) {
if ( LOG.isInfoEnabled() ) {
LOG.infof(
"Bidirectional association not managed for field [%s#%s]: @ManyToMany in java.util.Map attribute not supported ",
if ( BytecodeEnhancementLogging.LOGGER.isInfoEnabled() ) {
BytecodeEnhancementLogging.LOGGER.manyToManyInMapNotSupported(
managedCtClass.getName(),
persistentField.getName()
);
Expand All @@ -148,35 +143,29 @@ public static TypeDescription getTargetEntityClass(TypeDescription managedCtClas
AnnotationDescription.Loadable<ManyToOne> mto = persistentField.getAnnotation( ManyToOne.class );
AnnotationDescription.Loadable<ManyToMany> mtm = persistentField.getAnnotation( ManyToMany.class );

if ( oto == null && otm == null && mto == null && mtm == null ) {
return null;
}

AnnotationValue<?, ?> targetClass = null;
final AnnotationValue<?, ?> targetClass;
if ( oto != null ) {
targetClass = oto.getValue( new MethodDescription.ForLoadedMethod( OneToOne.class.getDeclaredMethod( "targetEntity" ) ) );
}
if ( otm != null ) {
else if ( otm != null ) {
targetClass = otm.getValue( new MethodDescription.ForLoadedMethod( OneToMany.class.getDeclaredMethod( "targetEntity" ) ) );
}
if ( mto != null ) {
else if ( mto != null ) {
targetClass = mto.getValue( new MethodDescription.ForLoadedMethod( ManyToOne.class.getDeclaredMethod( "targetEntity" ) ) );
}
if ( mtm != null ) {
else if ( mtm != null ) {
targetClass = mtm.getValue( new MethodDescription.ForLoadedMethod( ManyToMany.class.getDeclaredMethod( "targetEntity" ) ) );
}

if ( targetClass == null ) {
if ( LOG.isInfoEnabled() ) {
LOG.infof(
"Bidirectional association not managed for field [%s#%s]: Could not find target type",
else {
if ( BytecodeEnhancementLogging.LOGGER.isInfoEnabled() ) {
BytecodeEnhancementLogging.LOGGER.bidirectionalNotManagedCouldNotFindTargetType(
managedCtClass.getName(),
persistentField.getName()
);
}
return null;
}
else if ( !targetClass.resolve( TypeDescription.class ).represents( void.class ) ) {
if ( !targetClass.resolve( TypeDescription.class ).represents( void.class ) ) {
return targetClass.resolve( TypeDescription.class );
}
}
Expand Down Expand Up @@ -253,8 +242,8 @@ private static String getMappedByManyToMany(AnnotatedFieldDescription target, Ty
if ( context.isPersistentField( annotatedF )
&& target.getName().equals( getMappedBy( annotatedF, entityType( annotatedF.getType() ), context ) )
&& target.getDeclaringType().asErasure().isAssignableTo( entityType( annotatedF.getType() ) ) ) {
if ( LOG.isTraceEnabled() ) {
LOG.tracef(
if ( BytecodeEnhancementLogging.LOGGER.isTraceEnabled() ) {
BytecodeEnhancementLogging.LOGGER.tracef(
"mappedBy association for field [%s#%s] is [%s#%s]",
target.getDeclaringType().asErasure().getName(),
target.getName(),
Expand Down
28 changes: 12 additions & 16 deletions ...te-core/src/main/java/org/hibernate/bytecode/enhance/internal/bytebuddy/EnhancerImpl.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -45,8 +45,7 @@
import org.hibernate.engine.spi.CompositeOwner;
import org.hibernate.engine.spi.ExtendedSelfDirtinessTracker;
import org.hibernate.engine.spi.Managed;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.bytecode.enhance.internal.BytecodeEnhancementLogging;

import java.lang.annotation.Annotation;
import java.lang.reflect.Modifier;
Expand All @@ -69,7 +68,6 @@
import static org.hibernate.bytecode.enhance.internal.bytebuddy.FeatureMismatchException.Feature.DIRTY_CHECK;

public class EnhancerImpl implements Enhancer {
private static final CoreMessageLogger LOG = CoreLogging.messageLogger( Enhancer.class );

protected final ByteBuddyEnhancementContext enhancementContext;
private final ByteBuddyState byteBuddyState;
Expand Down Expand Up @@ -172,19 +170,19 @@ private DynamicType.Builder<?> doEnhance(Supplier<DynamicType.Builder<?>> builde
verifyReEnhancement( managedCtClass, infoAnnotation.load(), enhancementContext );
}
// verification succeeded (or not done) - we can simply skip the enhancement
LOG.tracef( "Skipping enhancement of [%s]: it's already annotated with @EnhancementInfo", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.skippingAlreadyAnnotated( managedCtClass.getName() );
return null;
}

// can't effectively enhance interfaces
if ( managedCtClass.isInterface() ) {
LOG.tracef( "Skipping enhancement of [%s]: it's an interface", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.skippingInterface( managedCtClass.getName() );
return null;
}

// can't effectively enhance records
if ( managedCtClass.isRecord() ) {
LOG.tracef( "Skipping enhancement of [%s]: it's a record", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.skippingRecord( managedCtClass.getName() );
return null;
}

Expand All @@ -194,7 +192,7 @@ private DynamicType.Builder<?> doEnhance(Supplier<DynamicType.Builder<?>> builde
return null;
}

LOG.tracef( "Enhancing [%s] as Entity", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.enhancingAsEntity( managedCtClass.getName() );
DynamicType.Builder<?> builder = builderSupplier.get();
builder = builder
.implement( constants.INTERFACES_for_ManagedEntity )
Expand Down Expand Up @@ -374,7 +372,7 @@ else if ( enhancementContext.isCompositeClass( managedCtClass ) ) {
return null;
}

LOG.tracef( "Enhancing [%s] as Composite", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.enhancingAsComposite( managedCtClass.getName() );

DynamicType.Builder<?> builder = builderSupplier.get();
builder = builder.implement( constants.INTERFACES_for_ManagedComposite );
Expand Down Expand Up @@ -412,18 +410,18 @@ else if ( enhancementContext.isMappedSuperclassClass( managedCtClass ) ) {
return null;
}

LOG.tracef( "Enhancing [%s] as MappedSuperclass", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.enhancingAsMappedSuperclass( managedCtClass.getName() );

DynamicType.Builder<?> builder = builderSupplier.get();
builder = builder.implement( constants.INTERFACES_for_ManagedMappedSuperclass );
return createTransformer( managedCtClass ).applyTo( builder );
}
else if ( enhancementContext.doExtendedEnhancement() ) {
LOG.tracef( "Extended enhancement of [%s]", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.extendedEnhancement( managedCtClass.getName() );
return createTransformer( managedCtClass ).applyExtended( builderSupplier.get() );
}
else {
LOG.tracef( "Skipping enhancement of [%s]: not entity or composite", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.skippingNotEntityOrComposite( managedCtClass.getName() );
return null;
}
}
Expand All @@ -436,7 +434,7 @@ private void verifyReEnhancement(
final String enhancementVersion = existingInfo.version();
if ( "ignore".equals( enhancementVersion ) ) {
// for testing
LOG.debugf( "Skipping re-enhancement version check for %s due to `ignore`", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.skippingReEnhancementVersionCheck( managedCtClass.getName() );
}
else if ( !Version.getVersionString().equals( enhancementVersion ) ) {
throw new VersionMismatchException( managedCtClass, enhancementVersion, Version.getVersionString() );
Expand Down Expand Up @@ -607,9 +605,7 @@ private static boolean checkUnsupportedAttributeNaming(TypeDescription managedCt
// We shouldn't even be in this method if using LEGACY, see top of this method.
return switch ( strategy ) {
case SKIP -> {
LOG.debugf(
"Skipping enhancement of [%s] because no field named [%s] could be found for property accessor method [%s]."
+ " To fix this, make sure all property accessor methods have a matching field.",
BytecodeEnhancementLogging.LOGGER.propertyAccessorNoFieldSkip(
managedCtClass.getName(),
fieldName,
methodDescription.getName()
Expand Down Expand Up @@ -666,7 +662,7 @@ private boolean alreadyEnhanced(TypeDescription managedCtClass) {
private DynamicType.Builder<?> addInterceptorHandling(DynamicType.Builder<?> builder, TypeDescription managedCtClass) {
// interceptor handling is only needed if class has lazy-loadable attributes
if ( enhancementContext.hasLazyLoadableAttributes( managedCtClass ) ) {
LOG.tracef( "Weaving in PersistentAttributeInterceptable implementation on [%s]", managedCtClass.getName() );
BytecodeEnhancementLogging.LOGGER.weavingPersistentAttributeInterceptable( managedCtClass.getName() );

builder = builder.implement( constants.INTERFACES_for_PersistentAttributeInterceptable );

Expand Down
8 changes: 2 additions & 6 deletions .../src/main/java/org/hibernate/bytecode/enhance/internal/bytebuddy/FieldAccessEnhancer.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,8 +16,7 @@
import org.hibernate.bytecode.enhance.internal.bytebuddy.EnhancerImpl.AnnotatedFieldDescription;
import org.hibernate.bytecode.enhance.spi.EnhancementException;
import org.hibernate.bytecode.enhance.spi.EnhancerConstants;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.bytecode.enhance.internal.BytecodeEnhancementLogging;

import net.bytebuddy.asm.AsmVisitorWrapper;
import net.bytebuddy.description.field.FieldList;
Expand All @@ -33,8 +32,6 @@

final class FieldAccessEnhancer implements AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper {

private static final CoreMessageLogger LOG = CoreLogging.messageLogger( FieldAccessEnhancer.class );

private final TypeDescription managedCtClass;

private final ByteBuddyEnhancementContext enhancementContext;
Expand Down Expand Up @@ -76,8 +73,7 @@ public void visitFieldInsn(int opcode, String owner, String name, String desc) {
&& !field.hasAnnotation( Id.class )
&& !field.getName().equals( "this$0" ) ) {

LOG.tracef(
"Extended enhancement: Transforming access to field [%s#%s] from method [%s#%s()]",
BytecodeEnhancementLogging.LOGGER.extendedTransformingFieldAccess(
declaredOwnerType.getName(),
field.getName(),
instrumentedType.getName(),
Expand Down
Loading
Loading