Implement CDI Interceptors for @CloseDBIfOpened and @WrapInTransaction

[spbolton]

Description

Implement CDI interceptor bindings for all 6 ByteBuddy Advice annotations to make them work correctly on CDI beans.

Background

ByteBuddy annotations currently fail silently on @ApplicationScoped CDI beans because Weld proxies do not copy method annotations. ByteBuddy's class matcher uses declaresMethod(isAnnotatedWith(...)) which cannot see annotations on proxy classes. This was the root cause of the connection leak fixed in #34134.

Current ByteBuddy Annotations (from ByteBuddyFactory):

1. @CloseDB → CloseDBAdvice - Closes and commits DB connection at method exit
2. @CloseDBIfOpened → CloseDBIfOpenedAdvice - Closes DB connection only if opened during method
3. @WrapInTransaction → WrapInTransactionAdvice - Wraps method in database transaction
4. @ExternalTransaction → ExternalTransactionAdvice - Creates separate transaction context
5. @logtime → LogTimeAdvice - Logs method execution time with configurable level
6. @EnterpriseFeature → EnterpriseFeatureAdvice - Validates enterprise license level before execution

Implementation Approach

For each annotation, implement CDI interceptor:

1. Database Connection/Transaction Annotations (@CloseDB, @CloseDBIfOpened, @WrapInTransaction, @ExternalTransaction):

• Add @InterceptorBinding meta-annotation to each
• Create corresponding interceptor classes with @AroundInvoke
• Replicate ByteBuddy advice logic in interceptor methods
• Handle connection lifecycle, transaction boundaries, and cleanup

2. Performance/Observability Annotations (@logtime):

• Add @InterceptorBinding meta-annotation
• Create LogTimeInterceptor with @AroundInvoke
• Use StopWatch to measure execution time
• Support configurable logging level (INFO/DEBUG)

3. Security/License Annotations (@EnterpriseFeature):

• Add @InterceptorBinding meta-annotation
• Create EnterpriseFeatureInterceptor with @AroundInvoke
• Validate license level before method execution
• Throw DotInvalidLicenseException if requirements not met

4. Enable interceptors in beans.xml:

<interceptors>
    <class>com.dotcms.business.interceptor.CloseDBInterceptor</class>
    <class>com.dotcms.business.interceptor.CloseDBIfOpenedInterceptor</class>
    <class>com.dotcms.business.interceptor.WrapInTransactionInterceptor</class>
    <class>com.dotcms.business.interceptor.ExternalTransactionInterceptor</class>
    <class>com.dotcms.business.interceptor.LogTimeInterceptor</class>
    <class>com.dotcms.business.interceptor.EnterpriseFeatureInterceptor</class>
</interceptors>

Technical Details

Why Both ByteBuddy and CDI Interceptors Can Coexist:

• ByteBuddy: Fires on non-CDI classes (instrumented at class load time)
• CDI Interceptors: Fire on CDI beans at proxy boundary (runtime)
• Both use same lifecycle guards (e.g., isNewConnection) to prevent double-processing
• Result: Annotations work correctly everywhere with backward compatibility

Priority Order (Critical → Nice-to-Have):

1. @CloseDBIfOpened - Connection leak prevention (showstopper bug)
2. @WrapInTransaction - Data integrity (high priority)
3. @CloseDB - Resource management (high priority)
4. @ExternalTransaction - Transaction isolation (medium priority)
5. @EnterpriseFeature - License enforcement (medium priority)
6. @logtime - Observability (low priority)

Benefits

• Fixes 7+ known legacy violations in UniqueFieldDataBaseUtil, JobQueueManagerAPIImpl, MetricsAPIImpl, CustomAttributeAPIImpl, HostWebAPIImpl, DBUniqueFieldValidationStrategy
• Eliminates manual wrapping - No more LocalTransaction.wrapReturn() boilerplate
• Prevents future leaks - Annotations work correctly on CDI beans
• Backward compatible - Non-CDI code continues to use ByteBuddy
• Consistent behavior - Same semantics across CDI and non-CDI classes

Acceptance Criteria

• All 6 annotations converted to @InterceptorBinding (backward compatible)
• CDI interceptor classes implemented for each annotation
• Interceptors enabled in beans.xml
• Unit tests verify interceptors fire correctly on CDI beans
• Integration tests verify no double-processing (ByteBuddy + CDI)
• ArchUnit test updated to allow annotations on CDI beans after interceptors enabled
• Known legacy violations migrated or documented
• Performance impact measured (interceptor overhead vs ByteBuddy)

Testing Strategy

1. Unit Tests: Mock CDI context, verify interceptor invocation
2. Integration Tests: Real CDI beans with annotations, verify behavior
3. Compatibility Tests: Ensure ByteBuddy still works on non-CDI classes
4. Performance Tests: Measure overhead of CDI interceptors vs ByteBuddy
5. Leak Tests: Run MetricsStatsCollector repeatedly, verify no connection leaks

References

• Root cause analysis: [DEFECT] Default site not being selected on login. #34134 (MetricStatsCollector connection leak)
• ByteBuddy implementation: com.dotcms.business.bytebuddy.ByteBuddyFactory
• ArchUnit test: CodingStandardsArchTest.applicationScopedBeansCannotUseByteBuddyAnnotations()

[spbolton]

Implementation Example: @CloseDBIfOpened CDI Interceptor

Here's a complete step-by-step example showing how to convert @CloseDBIfOpened from a ByteBuddy annotation to a CDI interceptor binding.

Step 1: Add @InterceptorBinding to the Annotation

Current annotation (com.dotmarketing.db.CloseDBIfOpened):

package com.dotmarketing.db;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CloseDBIfOpened {
}

Updated annotation (add @InterceptorBinding):

package com.dotmarketing.db;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.interceptor.InterceptorBinding;  // ← ADD THIS

@InterceptorBinding  // ← ADD THIS
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CloseDBIfOpened {
}

Step 2: Create the CDI Interceptor Class

New file (com.dotcms.business.interceptor.CloseDBIfOpenedInterceptor):

package com.dotcms.business.interceptor;

import com.dotmarketing.db.CloseDBIfOpened;
import com.dotmarketing.db.DbConnectionFactory;
import com.dotmarketing.util.Logger;

import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;
import java.io.Serializable;

/**
 * CDI interceptor for @CloseDBIfOpened annotation.
 * 
 * This interceptor provides the same functionality as CloseDBIfOpenedAdvice
 * but works correctly on CDI beans (e.g., @ApplicationScoped).
 * 
 * @see com.dotcms.business.bytebuddy.CloseDBIfOpenedAdvice
 * @see <a href="https://github.com/dotCMS/core/issues/34482">Issue #34482</a>
 */
@Interceptor
@CloseDBIfOpened
public class CloseDBIfOpenedInterceptor implements Serializable {

    private static final long serialVersionUID = 1L;

    @AroundInvoke
    public Object closeDBIfOpened(InvocationContext ctx) throws Exception {
        // Check if connection exists BEFORE method execution
        final boolean connectionExistsBefore = DbConnectionFactory.connectionExists();
        
        try {
            // Execute the business method
            return ctx.proceed();
            
        } finally {
            // Only close if connection was opened DURING this method execution
            if (!connectionExistsBefore && DbConnectionFactory.connectionExists()) {
                Logger.debug(this, () -> String.format(
                    "Closing DB connection opened during %s.%s()",
                    ctx.getTarget().getClass().getSimpleName(),
                    ctx.getMethod().getName()
                ));
                DbConnectionFactory.closeSilently();
            }
        }
    }
}

Key implementation details:

1. @Interceptor - Marks this as a CDI interceptor
2. @CloseDBIfOpened - Binds interceptor to the annotation
3. implements Serializable - Required for CDI interceptors
4. @AroundInvoke - Intercepts method execution
5. Connection guard - Replicates ByteBuddy advice logic:
   • Check connectionExists() BEFORE method
   • Execute method via ctx.proceed()
   • Close connection only if it was opened DURING this method

Step 3: Enable Interceptor in beans.xml

File: dotCMS/src/main/webapp/WEB-INF/beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                           http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd"
       version="1.1" bean-discovery-mode="all">
    
    <interceptors>
        <!-- Add new interceptor -->
        <class>com.dotcms.business.interceptor.CloseDBIfOpenedInterceptor</class>
        
        <!-- Other interceptors... -->
    </interceptors>
</beans>

Step 4: Usage - Before and After

Before (doesn't work on CDI beans):

@ApplicationScoped
public class MetricsAPIImpl implements MetricsAPI {
    
    @CloseDBIfOpened  // ← SILENTLY FAILS - ByteBuddy can't see this
    @Override
    public Optional<Object> getValue(String sqlQuery) {
        DotConnect dotConnect = new DotConnect();
        dotConnect.setSQL(sqlQuery);
        List<Map<String, Object>> results = dotConnect.loadResults();
        // Connection LEAKED - annotation didn't fire
        return results.isEmpty() ? Optional.empty() : Optional.of(results.get(0).get("value"));
    }
}

After (works correctly with CDI interceptor):

@ApplicationScoped
public class MetricsAPIImpl implements MetricsAPI {
    
    @CloseDBIfOpened  // ← NOW WORKS - CDI interceptor fires at proxy boundary
    @Override
    public Optional<Object> getValue(String sqlQuery) {
        DotConnect dotConnect = new DotConnect();
        dotConnect.setSQL(sqlQuery);
        List<Map<String, Object>> results = dotConnect.loadResults();
        // Connection PROPERLY CLOSED by interceptor
        return results.isEmpty() ? Optional.empty() : Optional.of(results.get(0).get("value"));
    }
}

How ByteBuddy and CDI Interceptors Coexist

Non-CDI classes (e.g., POJOs, utilities):

• ByteBuddy advice fires (instrumented at class load time)
• CDI interceptor does NOT fire (no proxy)
• Result: Works as before ✓

CDI beans (e.g., @ApplicationScoped):

• CDI interceptor fires at proxy boundary
• ByteBuddy advice MAY fire inside (depends on how Weld delegates)
• Both use same guard (connectionExistsBefore) to prevent double-close
• Result: Works correctly, no conflicts ✓

Verification Tests

Unit test (CDI context):

@ExtendWith(CDIExtension.class)
class CloseDBIfOpenedInterceptorTest {
    
    @Inject
    @ApplicationScoped
    TestBean testBean;  // CDI proxy with interceptor
    
    @Test
    void interceptorClosesConnectionOpenedDuringMethod() {
        // Given: No connection exists
        assertFalse(DbConnectionFactory.connectionExists());
        
        // When: Call method that opens connection
        testBean.methodThatOpensConnection();
        
        // Then: Connection was closed by interceptor
        assertFalse(DbConnectionFactory.connectionExists());
    }
    
    @Test
    void interceptorDoesNotCloseExistingConnection() {
        // Given: Connection already exists
        DbConnectionFactory.getConnection();
        assertTrue(DbConnectionFactory.connectionExists());
        
        // When: Call method (doesn't open new connection)
        testBean.methodThatUsesExistingConnection();
        
        // Then: Connection still exists (not closed)
        assertTrue(DbConnectionFactory.connectionExists());
        
        // Cleanup
        DbConnectionFactory.closeSilently();
    }
}

@ApplicationScoped
class TestBean {
    @CloseDBIfOpened
    public void methodThatOpensConnection() {
        DotConnect dc = new DotConnect();
        dc.setSQL("SELECT 1");
        dc.loadResults();
    }
    
    @CloseDBIfOpened
    public void methodThatUsesExistingConnection() {
        // Uses existing connection, doesn't open new one
    }
}

Implementation Checklist for Each Annotation

Apply this pattern to all 6 annotations:

• @CloseDBIfOpened - Connection lifecycle management
• @CloseDB - Unconditional connection close + commit
• @WrapInTransaction - Transaction wrapping with commit/rollback
• @ExternalTransaction - Separate transaction context creation
• @logtime - Method execution timing with configurable log level
• @EnterpriseFeature - License level validation before method execution

Each follows the same 4-step pattern:

1. Add @InterceptorBinding to annotation
2. Create interceptor class with @AroundInvoke
3. Enable in beans.xml
4. Write unit tests

[spbolton]

Refined Architecture: Common Service Layer Pattern

Based on the existing goal to decouple ByteBuddy Advice from internal service locators and enable build-time execution, we should implement a common service layer that both ByteBuddy Advice and CDI Interceptors delegate to.

Current Problem: Duplicate Logic + Runtime Coupling

Today's architecture (problematic):

ByteBuddy Advice → Direct calls to DbConnectionFactory, LocalTransaction, etc.
                   (Runtime dependencies, can't run at build time)

Naive CDI interceptor approach (would duplicate logic):

ByteBuddy Advice     → DbConnectionFactory.closeSilently()
CDI Interceptor      → DbConnectionFactory.closeSilently()
                        ↑ DUPLICATE LOGIC

Proposed Architecture: Shared Service Layer

New architecture (clean):

ByteBuddy Advice     ┐
                     ├─→ TransactionService (common logic)
CDI Interceptor      ┘

Implementation Pattern

Step 1: Create Service Interface & Implementation

File: com.dotcms.business.transaction.TransactionService

package com.dotcms.business.transaction;

import java.util.function.Supplier;

/**
 * Service layer for database transaction and connection management.
 * 
 * This interface abstracts transaction logic away from both ByteBuddy Advice
 * and CDI Interceptors, enabling:
 * - Build-time ByteBuddy execution (no runtime service locator dependency)
 * - Single source of truth for transaction semantics
 * - Easier unit testing with mocks
 * 
 * @see com.dotcms.business.bytebuddy (ByteBuddy Advice callers)
 * @see com.dotcms.business.interceptor (CDI Interceptor callers)
 */
public interface TransactionService {
    
    /**
     * Close DB connection only if it was opened during the current operation.
     * 
     * @param connectionExistedBefore whether connection existed before operation started
     * @param shouldCloseConnection whether annotation permits closing (from @CloseDBIfOpened.connection())
     */
    void closeDBIfOpened(boolean connectionExistedBefore, boolean shouldCloseConnection);
    
    /**
     * Unconditionally close and commit DB connection.
     */
    void closeDB();
    
    /**
     * Wrap operation in a transaction with commit/rollback.
     * 
     * @param operation the operation to execute
     * @param externalize whether to create external transaction context
     * @return operation result
     * @throws Exception if operation or transaction fails
     */
    <T> T wrapInTransaction(Supplier<T> operation, boolean externalize) throws Exception;
    
    /**
     * Check if a DB connection exists on current thread.
     * 
     * @return true if connection exists
     */
    boolean connectionExists();
}

File: com.dotcms.business.transaction.TransactionServiceImpl

package com.dotcms.business.transaction;

import com.dotcms.repackage.net.sf.hibernate.Session;
import com.dotmarketing.db.DbConnectionFactory;
import com.dotmarketing.db.HibernateUtil;
import com.dotmarketing.db.LocalTransaction;
import com.dotmarketing.util.Logger;

import javax.enterprise.context.ApplicationScoped;
import java.sql.Connection;
import java.util.function.Supplier;

/**
 * Default implementation of TransactionService using dotCMS database utilities.
 * 
 * This class contains the actual transaction logic that was previously embedded
 * in ByteBuddy Advice classes. Now both ByteBuddy and CDI Interceptors delegate
 * to this service.
 */
@ApplicationScoped
public class TransactionServiceImpl implements TransactionService {
    
    @Override
    public void closeDBIfOpened(boolean connectionExistedBefore, boolean shouldCloseConnection) {
        // Only close if: (1) connection was opened during operation, (2) annotation permits
        if (!connectionExistedBefore && shouldCloseConnection && connectionExists()) {
            Logger.debug(this, "Closing DB connection opened during annotated method");
            DbConnectionFactory.closeSilently();
        }
    }
    
    @Override
    public void closeDB() {
        try {
            DbConnectionFactory.closeAndCommit();
        } finally {
            DbConnectionFactory.closeSilently();
        }
    }
    
    @Override
    public <T> T wrapInTransaction(Supplier<T> operation, boolean externalize) throws Exception {
        if (externalize) {
            return wrapInExternalTransaction(operation);
        } else {
            return LocalTransaction.wrapReturn(() -> operation.get());
        }
    }
    
    private <T> T wrapInExternalTransaction(Supplier<T> operation) throws Exception {
        // Save current connection/session
        final Connection currentConnection = DbConnectionFactory.getConnection();
        final Session currentSession = HibernateUtil.getSession();
        
        // Create new transaction connection
        final Connection newTransactionConnection = DbConnectionFactory.getDataSource().getConnection();
        
        try {
            // Override thread context
            DbConnectionFactory.setConnection(newTransactionConnection);
            final Session newSession = HibernateUtil.createNewSession(newTransactionConnection);
            HibernateUtil.setSession(newSession);
            HibernateUtil.startTransaction();
            
            // Execute operation
            T result = operation.get();
            
            // Commit transaction
            HibernateUtil.commitTransaction();
            return result;
            
        } catch (Throwable e) {
            HibernateUtil.rollbackTransaction();
            throw e;
        } finally {
            HibernateUtil.closeSessionSilently();
            // Restore previous context
            HibernateUtil.setSession(currentSession);
            DbConnectionFactory.setConnection(currentConnection);
        }
    }
    
    @Override
    public boolean connectionExists() {
        return DbConnectionFactory.connectionExists();
    }
}

Step 2: Refactor ByteBuddy Advice to Delegate

Before (tightly coupled):

public class CloseDBIfOpenedAdvice {
    @Advice.OnMethodExit(inline = false, onThrowable = Throwable.class)
    public static void exit(@Advice.Origin Method method, @Advice.Enter boolean isNewConnection) {
        final CloseDBIfOpened closeDB = getMethodAnnotation(method, CloseDBIfOpened.class);
        
        if (null != closeDB && closeDB.connection() && isNewConnection) {
            DbConnectionFactory.closeSilently();  // ← Tightly coupled
        }
    }
}

After (delegating to service):

public class CloseDBIfOpenedAdvice {
    // Static reference to service (can be injected at build time)
    private static TransactionService transactionService = TransactionServiceHolder.getInstance();
    
    @Advice.OnMethodEnter(inline = false)
    public static boolean enter() {
        return transactionService.connectionExists();
    }
    
    @Advice.OnMethodExit(inline = false, onThrowable = Throwable.class)
    public static void exit(@Advice.Origin Method method, @Advice.Enter boolean connectionExistedBefore) {
        final CloseDBIfOpened closeDB = getMethodAnnotation(method, CloseDBIfOpened.class);
        final boolean shouldClose = closeDB != null && closeDB.connection();
        
        // Delegate to service layer
        transactionService.closeDBIfOpened(connectionExistedBefore, shouldClose);
    }
}

Service holder for static access:

/**
 * Holder for TransactionService instance to support static ByteBuddy Advice methods.
 * 
 * At runtime: Initialized with CDI bean
 * At build time: Can be initialized with build-time compatible implementation
 */
public class TransactionServiceHolder {
    private static TransactionService instance;
    
    public static void setInstance(TransactionService service) {
        instance = service;
    }
    
    public static TransactionService getInstance() {
        if (instance == null) {
            // Lazy initialization for runtime
            instance = CDI.current().select(TransactionService.class).get();
        }
        return instance;
    }
}

Step 3: CDI Interceptor Also Delegates

@Interceptor
@CloseDBIfOpened
public class CloseDBIfOpenedInterceptor implements Serializable {
    
    @Inject
    private TransactionService transactionService;  // ← Injected
    
    @AroundInvoke
    public Object closeDBIfOpened(InvocationContext ctx) throws Exception {
        final boolean connectionExistedBefore = transactionService.connectionExists();
        final CloseDBIfOpened annotation = ctx.getMethod().getAnnotation(CloseDBIfOpened.class);
        final boolean shouldClose = annotation != null && annotation.connection();
        
        try {
            return ctx.proceed();
        } finally {
            // Delegate to same service layer as ByteBuddy
            transactionService.closeDBIfOpened(connectionExistedBefore, shouldClose);
        }
    }
}

Benefits of This Architecture

1. Single Source of Truth

TransactionServiceImpl.closeDBIfOpened()
        ↑                      ↑
ByteBuddy Advice      CDI Interceptor

• Change logic once, both mechanisms benefit
• No risk of divergent behavior
• Easier code review

2. Build-Time ByteBuddy Support

Runtime dependency removed:

// Old (runtime only)
DbConnectionFactory.closeSilently();  // Requires runtime classes

// New (build-time compatible)
transactionService.closeDBIfOpened(...);  // Interface can have build-time impl

Build-time implementation:

public class BuildTimeTransactionService implements TransactionService {
    @Override
    public void closeDBIfOpened(boolean connectionExistedBefore, boolean shouldCloseConnection) {
        // No-op at build time, or generate bytecode that calls runtime version
        // ByteBuddy can inline this at build time
    }
    
    @Override
    public boolean connectionExists() {
        // Generate bytecode: DbConnectionFactory.connectionExists()
        return false;  // Placeholder for code generation
    }
}

3. Testability

Test the service in isolation:

class TransactionServiceImplTest {
    @Test
    void closeDBIfOpened_closesWhenNewConnectionAndAllowed() {
        // Arrange
        TransactionService service = new TransactionServiceImpl();
        DbConnectionFactory.getConnection();  // Open connection
        
        // Act
        service.closeDBIfOpened(
            false,  // connectionExistedBefore = false (new connection)
            true    // shouldCloseConnection = true
        );
        
        // Assert
        assertFalse(DbConnectionFactory.connectionExists());
    }
    
    @Test
    void closeDBIfOpened_doesNotCloseExistingConnection() {
        // Arrange
        DbConnectionFactory.getConnection();  // Existing connection
        
        // Act
        service.closeDBIfOpened(
            true,   // connectionExistedBefore = true
            true    // shouldCloseConnection = true
        );
        
        // Assert
        assertTrue(DbConnectionFactory.connectionExists());  // Still open
    }
}

Mock service for Advice/Interceptor tests:

@Test
void byteBuddyAdvice_delegatesToService() {
    // Arrange
    TransactionService mockService = mock(TransactionService.class);
    TransactionServiceHolder.setInstance(mockService);
    
    // Act
    CloseDBIfOpenedAdvice.exit(method, false);  // connectionExistedBefore = false
    
    // Assert
    verify(mockService).closeDBIfOpened(false, true);
}

Implementation Plan (Updated)

Phase 1: Create Service Layer

• Define TransactionService interface
• Implement TransactionServiceImpl with current logic
• Create TransactionServiceHolder for static access
• Write comprehensive unit tests for service layer

Phase 2: Refactor ByteBuddy Advice

• Update CloseDBIfOpenedAdvice to delegate to service
• Update CloseDBAdvice to delegate to service
• Update WrapInTransactionAdvice to delegate to service
• Update ExternalTransactionAdvice to delegate to service
• Verify ByteBuddy still works on non-CDI classes

Phase 3: Implement CDI Interceptors

• Add @InterceptorBinding to all 6 annotations
• Create CDI interceptor classes that delegate to service
• Enable interceptors in beans.xml
• Verify CDI interceptors work on @ApplicationScoped beans

Phase 4: Build-Time Support (Future)

• Create BuildTimeTransactionService implementation
• Configure ByteBuddy to use build-time service
• Migrate from runtime to build-time instrumentation

Migration Path

Non-breaking: All changes are internal refactoring

• ✅ Annotations unchanged (backward compatible)
• ✅ Behavior unchanged (delegates to same logic)
• ✅ Can be done incrementally (one annotation at a time)

Additional Services to Extract

Following the same pattern, extract other annotation logic:

// For @LogTime
public interface LoggingService {
    TimerInfo startTimer(Method method, String loggingLevel);
    void stopTimer(TimerInfo timer);
}

// For @EnterpriseFeature
public interface LicenseValidationService {
    void validateLicenseLevel(LicenseLevel requiredLevel, String errorMessage);
}

This refactoring aligns with dotCMS architectural goals:

• Decouple from internal service locators
• Enable build-time ByteBuddy execution
• Improve testability and maintainability
• Support both ByteBuddy and CDI interceptors via shared services