You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by ro...@apache.org on 2022/05/11 12:29:52 UTC

[activemq-artemis] branch new-logging updated (37e2684ed5 -> d19b372d30)

This is an automated email from the ASF dual-hosted git repository.

robbie pushed a change to branch new-logging
in repository https://gitbox.apache.org/repos/asf/activemq-artemis.git


    from 37e2684ed5 fixing formatting with {} some real implementation on Processor
     new e7ea645fa2 update more of artemis-jdbc-store, but not all in order to note specific issues
     new d19b372d30 some TODOs around logger names etc

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../jdbc/store/drivers/AbstractJDBCDriver.java     |  14 +-
 .../jdbc/store/drivers/JDBCConnectionProvider.java |  13 +-
 .../artemis/jdbc/store/drivers/JDBCUtils.java      |  11 +-
 .../jdbc/store/file/JDBCSequentialFile.java        |   5 +-
 .../jdbc/store/file/JDBCSequentialFileFactory.java |   7 +-
 .../file/JDBCSequentialFileFactoryDriver.java      |   7 +-
 .../jdbc/store/journal/JDBCJournalImpl.java        |   7 +-
 .../jdbc/store/journal/JDBCJournalRecord.java      |   2 +
 .../jdbc/store/logging/LoggingConnection.java      | 112 +++---
 .../store/logging/LoggingPreparedStatement.java    | 118 +++---
 .../jdbc/store/logging/LoggingResultSet.java       | 395 ++++++++++-----------
 .../jdbc/store/logging/LoggingStatement.java       | 108 +++---
 .../jdbc/store/sql/PropertySQLProvider.java        |   9 +-
 .../artemis/journal/ActiveMQJournalBundle.java     |   4 +-
 .../artemis/journal/ActiveMQJournalLogger.java     |  66 ++--
 .../activemq/artemis/logprocessor/CodeFactory.java |   4 +-
 16 files changed, 445 insertions(+), 437 deletions(-)


[activemq-artemis] 01/02: update more of artemis-jdbc-store, but not all in order to note specific issues

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

robbie pushed a commit to branch new-logging
in repository https://gitbox.apache.org/repos/asf/activemq-artemis.git

commit e7ea645fa22dcb1072e415906e3988d16a4e851a
Author: Robbie Gemmell <ro...@apache.org>
AuthorDate: Wed May 11 13:08:20 2022 +0100

    update more of artemis-jdbc-store, but not all in order to note specific issues
---
 .../jdbc/store/drivers/AbstractJDBCDriver.java     |  14 +-
 .../jdbc/store/drivers/JDBCConnectionProvider.java |  11 +-
 .../artemis/jdbc/store/drivers/JDBCUtils.java      |  11 +-
 .../jdbc/store/file/JDBCSequentialFile.java        |   5 +-
 .../jdbc/store/file/JDBCSequentialFileFactory.java |   5 +-
 .../file/JDBCSequentialFileFactoryDriver.java      |   7 +-
 .../jdbc/store/journal/JDBCJournalImpl.java        |   7 +-
 .../jdbc/store/logging/LoggingConnection.java      | 112 +++---
 .../store/logging/LoggingPreparedStatement.java    | 118 +++---
 .../jdbc/store/logging/LoggingResultSet.java       | 395 ++++++++++-----------
 .../jdbc/store/logging/LoggingStatement.java       | 108 +++---
 .../jdbc/store/sql/PropertySQLProvider.java        |   9 +-
 .../artemis/journal/ActiveMQJournalBundle.java     |   4 +-
 .../artemis/journal/ActiveMQJournalLogger.java     |  66 ++--
 .../activemq/artemis/logprocessor/CodeFactory.java |   4 +-
 15 files changed, 439 insertions(+), 437 deletions(-)

diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/AbstractJDBCDriver.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/AbstractJDBCDriver.java
index c954d147ec..7b775a98d7 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/AbstractJDBCDriver.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/AbstractJDBCDriver.java
@@ -75,11 +75,11 @@ public abstract class AbstractJDBCDriver {
             }
             connection.commit();
          } catch (SQLException e) {
-            logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e, dropTableSql));
+            logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e, dropTableSql).toString());
             try {
                connection.rollback();
             } catch (SQLException rollbackEx) {
-               logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), rollbackEx, dropTableSql));
+               logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), rollbackEx, dropTableSql).toString());
                throw rollbackEx;
             }
             throw e;
@@ -102,7 +102,7 @@ public abstract class AbstractJDBCDriver {
                   if (rs != null) {
                      final SQLWarning sqlWarning = rs.getWarnings();
                      if (sqlWarning != null) {
-                        logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), sqlWarning));
+                        logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), sqlWarning).toString());
                      }
                   }
                } else {
@@ -142,7 +142,7 @@ public abstract class AbstractJDBCDriver {
                   //some DBMS just return stale information about table existence
                   //and can fail on later attempts to access them
                   if (logger.isTraceEnabled()) {
-                     logger.trace(JDBCUtils.appendSQLExceptionDetails(new StringBuilder("Can't verify the initialization of table ").append(tableName).append(" due to:"), e, sqlProvider.getCountJournalRecordsSQL()));
+                     logger.trace(JDBCUtils.appendSQLExceptionDetails(new StringBuilder("Can't verify the initialization of table ").append(tableName).append(" due to:"), e, sqlProvider.getCountJournalRecordsSQL()).toString());
                   }
                   try {
                      connection.rollback();
@@ -159,7 +159,7 @@ public abstract class AbstractJDBCDriver {
                      statement.executeUpdate(sql);
                      final SQLWarning statementSqlWarning = statement.getWarnings();
                      if (statementSqlWarning != null) {
-                        logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), statementSqlWarning, sql));
+                        logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), statementSqlWarning, sql).toString());
                      }
                   }
                }
@@ -168,11 +168,11 @@ public abstract class AbstractJDBCDriver {
             }
          } catch (SQLException e) {
             final String sqlStatements = String.join("\n", sqls);
-            logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e, sqlStatements));
+            logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e, sqlStatements).toString());
             try {
                connection.rollback();
             } catch (SQLException rollbackEx) {
-               logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), rollbackEx, sqlStatements));
+               logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), rollbackEx, sqlStatements).toString());
                throw rollbackEx;
             }
             throw e;
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java
index 9f972d39d8..c85eec48e0 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java
@@ -26,11 +26,12 @@ import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.activemq.artemis.jdbc.store.logging.LoggingConnection;
 import org.apache.activemq.artemis.jdbc.store.sql.PropertySQLProvider;
 import org.apache.activemq.artemis.journal.ActiveMQJournalLogger;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class JDBCConnectionProvider {
 
-   private static final Logger logger = Logger.getLogger(JDBCConnectionProvider.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCConnectionProvider.class);
    private DataSource dataSource;
    private Executor networkTimeoutExecutor;
    private int networkTimeoutMillis;
@@ -64,7 +65,7 @@ public class JDBCConnectionProvider {
             connection = new LoggingConnection(connection, logger);
          }
       } catch (SQLException e) {
-         logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e));
+         logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e).toString());
          throw e;
       }
 
@@ -78,7 +79,7 @@ public class JDBCConnectionProvider {
                connection.setNetworkTimeout(this.networkTimeoutExecutor, this.networkTimeoutMillis);
             } catch (SQLException e) {
                supportNetworkTimeout = false;
-               logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e));
+               logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e).toString());
                ActiveMQJournalLogger.LOGGER.warn("Unable to set a network timeout on the JDBC connection: won't retry again in the future");
             } catch (Throwable throwable) {
                supportNetworkTimeout = false;
@@ -112,7 +113,7 @@ public class JDBCConnectionProvider {
             }
          }
       } catch (SQLException e) {
-         logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e));
+         logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e).toString());
       }
    }
 
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCUtils.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCUtils.java
index 37c1e97d89..9eeb13e72c 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCUtils.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCUtils.java
@@ -21,28 +21,29 @@ import java.util.Map;
 
 import org.apache.activemq.artemis.jdbc.store.sql.PropertySQLProvider;
 import org.apache.activemq.artemis.jdbc.store.sql.SQLProvider;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class JDBCUtils {
 
-   private static final Logger logger = Logger.getLogger(JDBCUtils.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCUtils.class);
 
    public static SQLProvider.Factory getSQLProviderFactory(String url) {
       PropertySQLProvider.Factory.SQLDialect dialect = PropertySQLProvider.Factory.identifyDialect(url);
-      logger.tracef("getSQLProvider Returning SQL provider for dialect %s for url::%s", dialect, url);
+      logger.trace("getSQLProvider Returning SQL provider for dialect {} for url::{}", dialect, url);
       return new PropertySQLProvider.Factory(dialect);
    }
 
    public static SQLProvider getSQLProvider(String driverClass, String tableName, SQLProvider.DatabaseStoreType storeType) {
       PropertySQLProvider.Factory.SQLDialect dialect = PropertySQLProvider.Factory.identifyDialect(driverClass);
-      logger.tracef("getSQLProvider Returning SQL provider for dialect %s for driver::%s, tableName::%s", dialect, driverClass, tableName);
+      logger.trace("getSQLProvider Returning SQL provider for dialect {} for driver::{}, tableName::{}", dialect, driverClass, tableName);
       PropertySQLProvider.Factory factory = new PropertySQLProvider.Factory(dialect);
       return factory.create(tableName, storeType);
    }
 
    public static SQLProvider getSQLProvider(Map<String, Object> dataSourceProperties, String tableName, SQLProvider.DatabaseStoreType storeType) {
       PropertySQLProvider.Factory.SQLDialect dialect = PropertySQLProvider.Factory.investigateDialect(dataSourceProperties);
-      logger.tracef("getSQLProvider Returning SQL provider for dialect %s, tableName::%s", dialect, tableName);
+      logger.trace("getSQLProvider Returning SQL provider for dialect {}, tableName::{}", dialect, tableName);
       PropertySQLProvider.Factory factory = new PropertySQLProvider.Factory(dialect);
       return factory.create(tableName, storeType);
    }
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFile.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFile.java
index 1ee9c77677..54255cf88e 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFile.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFile.java
@@ -34,11 +34,12 @@ import org.apache.activemq.artemis.core.io.SequentialFile;
 import org.apache.activemq.artemis.core.io.buffer.TimedBuffer;
 import org.apache.activemq.artemis.core.journal.EncodingSupport;
 import org.apache.activemq.artemis.core.journal.impl.SimpleWaitIOCallback;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class JDBCSequentialFile implements SequentialFile {
 
-   private static final Logger logger = Logger.getLogger(JDBCSequentialFile.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCSequentialFile.class);
 
    private final String filename;
 
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java
index c9169c52e8..cba736b05c 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java
@@ -34,11 +34,12 @@ import org.apache.activemq.artemis.jdbc.store.drivers.JDBCConnectionProvider;
 import org.apache.activemq.artemis.jdbc.store.sql.SQLProvider;
 import org.apache.activemq.artemis.journal.ActiveMQJournalLogger;
 import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class JDBCSequentialFileFactory implements SequentialFileFactory, ActiveMQComponent {
 
-   private static final Logger logger = Logger.getLogger(JDBCSequentialFile.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCSequentialFile.class);
 
    private boolean started;
 
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactoryDriver.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactoryDriver.java
index ab6906c3cb..5f3f81d2a7 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactoryDriver.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactoryDriver.java
@@ -29,12 +29,13 @@ import java.util.List;
 import org.apache.activemq.artemis.jdbc.store.drivers.AbstractJDBCDriver;
 import org.apache.activemq.artemis.jdbc.store.drivers.JDBCConnectionProvider;
 import org.apache.activemq.artemis.jdbc.store.sql.SQLProvider;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 @SuppressWarnings("SynchronizeOnNonFinalField")
 public class JDBCSequentialFileFactoryDriver extends AbstractJDBCDriver {
 
-   private static final Logger logger = Logger.getLogger(JDBCSequentialFileFactoryDriver.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCSequentialFileFactoryDriver.class);
 
    protected String deleteFile;
    protected String createFile;
@@ -317,7 +318,7 @@ public class JDBCSequentialFileFactoryDriver extends AbstractJDBCDriver {
                      final long filePosition = file.position();
                      readLength = (int) calculateReadLength(blobLength, bytesRemaining, filePosition);
                      if (logger.isDebugEnabled()) {
-                        logger.debugf("trying read %d bytes: blobLength = %d bytesRemaining = %d filePosition = %d",
+                        logger.debug("trying read {} bytes: blobLength = {} bytesRemaining = {} filePosition = {}",
                                 readLength, blobLength, bytesRemaining, filePosition);
                      }
                      if (readLength < 0) {
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalImpl.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalImpl.java
index a4281b33dc..90d7967e3f 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalImpl.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalImpl.java
@@ -54,11 +54,12 @@ import org.apache.activemq.artemis.jdbc.store.drivers.AbstractJDBCDriver;
 import org.apache.activemq.artemis.jdbc.store.drivers.JDBCConnectionProvider;
 import org.apache.activemq.artemis.jdbc.store.sql.SQLProvider;
 import org.apache.activemq.artemis.utils.collections.SparseArrayLinkedList;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class JDBCJournalImpl extends AbstractJDBCDriver implements Journal {
 
-   private static final Logger logger = Logger.getLogger(JDBCJournalImpl.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCJournalImpl.class);
 
    // Sync Delay in ms
    //private static final int SYNC_DELAY = 5;
@@ -159,7 +160,7 @@ public class JDBCJournalImpl extends AbstractJDBCDriver implements Journal {
 
    @Override
    protected void prepareStatements() {
-      logger.tracef("preparing statements");
+      logger.trace("preparing statements");
       insertJournalRecords = sqlProvider.getInsertJournalRecordsSQL();
       selectJournalRecords = sqlProvider.getSelectJournalRecordsSQL();
       countJournalRecords = sqlProvider.getCountJournalRecordsSQL();
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingConnection.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingConnection.java
index 8a9284abeb..b2dc1dc4b4 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingConnection.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingConnection.java
@@ -37,7 +37,7 @@ import java.util.Map;
 import java.util.Properties;
 import java.util.concurrent.Executor;
 
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
 
 public class LoggingConnection implements Connection {
 
@@ -47,8 +47,6 @@ public class LoggingConnection implements Connection {
 
    private Logger logger;
 
-   private Logger.Level level = Logger.Level.TRACE;
-
    public LoggingConnection(Connection connection, Logger logger) {
       this.connection = connection;
       this.logger = logger;
@@ -66,132 +64,132 @@ public class LoggingConnection implements Connection {
    @Override
    public Statement createStatement() throws SQLException {
       LoggingStatement statement = new LoggingStatement(connection.createStatement(), logger);
-      logger.logf(level, "%s.createStatement() = %s", connectionID, statement.getStatementID());
+      logger.trace("{}.createStatement() = {}", connectionID, statement.getStatementID());
       return statement;
    }
 
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
       LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql), logger);
-      logger.logf(level, "%s.prepareStatement(%s) = %s", connectionID, sql, statement.getStatementID());
+      logger.trace("{}.prepareStatement({}) = {}", connectionID, sql, statement.getStatementID());
       return statement;
    }
 
    @Override
    public CallableStatement prepareCall(String sql) throws SQLException {
       CallableStatement statement = connection.prepareCall(sql);
-      logger.logf(level, "%s.prepareCall(%s) = %s", connectionID, sql, LoggingUtil.getID(statement));
+      logger.trace("{}.prepareCall({}) = {}", connectionID, sql, LoggingUtil.getID(statement));
       return statement;
    }
 
    @Override
    public String nativeSQL(String sql) throws SQLException {
       String x = connection.nativeSQL(sql);
-      logger.logf(level, "%s.nativeSQL(%s) = %s", connectionID, sql, x);
+      logger.trace("{}.nativeSQL({}) = {}", connectionID, sql, x);
       return x;
    }
 
    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {
-      logger.logf(level, "%s.setAutoCommit(%s)", connectionID, autoCommit);
+      logger.trace("{}.setAutoCommit({})", connectionID, autoCommit);
       connection.setAutoCommit(autoCommit);
    }
 
    @Override
    public boolean getAutoCommit() throws SQLException {
       boolean x = connection.getAutoCommit();
-      logger.logf(level, "%s.getAutoCommit() = %s", connectionID, x);
+      logger.trace("{}.getAutoCommit() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void commit() throws SQLException {
-      logger.logf(level, "%s.commit()", connectionID);
+      logger.trace("{}.commit()", connectionID);
       connection.commit();
    }
 
    @Override
    public void rollback() throws SQLException {
-      logger.logf(level, "%s.rollback()", connectionID);
+      logger.trace("{}.rollback()", connectionID);
       connection.rollback();
    }
 
    @Override
    public void close() throws SQLException {
-      logger.logf(level, "%s.close()", connectionID);
+      logger.trace("{}.close()", connectionID);
       connection.close();
    }
 
    @Override
    public boolean isClosed() throws SQLException {
       boolean x = connection.isClosed();
-      logger.logf(level, "%s.isClosed() = %s", connectionID, x);
+      logger.trace("{}.isClosed() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
       DatabaseMetaData x = connection.getMetaData();
-      logger.logf(level, "%s.getMetaData() = %s", connectionID, x);
+      logger.trace("{}.getMetaData() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {
-      logger.logf(level, "%s.setReadOnly(%s)", connectionID, readOnly);
+      logger.trace("{}.setReadOnly({})", connectionID, readOnly);
       connection.setReadOnly(readOnly);
    }
 
    @Override
    public boolean isReadOnly() throws SQLException {
       boolean x = connection.isReadOnly();
-      logger.logf(level, "%s.isReadOnly() = %s", connectionID, x);
+      logger.trace("{}.isReadOnly() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void setCatalog(String catalog) throws SQLException {
-      logger.logf(level, "%s.setCatalog(%s)", connectionID, catalog);
+      logger.trace("{}.setCatalog({})", connectionID, catalog);
       connection.setCatalog(catalog);
    }
 
    @Override
    public String getCatalog() throws SQLException {
       String x = connection.getCatalog();
-      logger.logf(level, "%s.getCatalog() = %s", connectionID, x);
+      logger.trace("{}.getCatalog() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void setTransactionIsolation(int level) throws SQLException {
-      logger.logf(this.level, "%s.setTransactionIsolation(%s)", connectionID, level);
+      logger.trace("{}.setTransactionIsolation({})", connectionID, level);
       connection.setTransactionIsolation(level);
    }
 
    @Override
    public int getTransactionIsolation() throws SQLException {
       int x = connection.getTransactionIsolation();
-      logger.logf(level, "%s.getTransactionIsolation() = %s", connectionID, x);
+      logger.trace("{}.getTransactionIsolation() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public SQLWarning getWarnings() throws SQLException {
       SQLWarning x = connection.getWarnings();
-      logger.logf(level, "%s.getWarnings() = %s", connectionID, x);
+      logger.trace("{}.getWarnings() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void clearWarnings() throws SQLException {
-      logger.logf(level, "%s.clearWarnings()", connectionID);
+      logger.trace("{}.clearWarnings()", connectionID);
       connection.clearWarnings();
    }
 
    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
       LoggingStatement statement = new LoggingStatement(connection.createStatement(resultSetType, resultSetConcurrency), logger);
-      logger.logf(level, "%s.createStatement(%s, %s) = %s", connectionID, resultSetType, resultSetConcurrency, statement.getStatementID());
+      logger.trace("{}.createStatement({}, {}) = {}", connectionID, resultSetType, resultSetConcurrency, statement.getStatementID());
       return statement;
    }
 
@@ -200,66 +198,66 @@ public class LoggingConnection implements Connection {
                                              int resultSetType,
                                              int resultSetConcurrency) throws SQLException {
       LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, resultSetType, resultSetConcurrency), logger);
-      logger.logf(level, "%s.prepareStatement(%s, %s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, statement.getStatementID());
+      logger.trace("{}.prepareStatement({}, {}, {}) = {}", connectionID, sql, resultSetType, resultSetConcurrency, statement.getStatementID());
       return statement;
    }
 
    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
       CallableStatement statement = connection.prepareCall(sql, resultSetType, resultSetConcurrency);
-      logger.logf(level, "%s.createStatement(%s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, LoggingUtil.getID(statement));
+      logger.trace("{}.createStatement({}, {}) = {}", connectionID, sql, resultSetType, resultSetConcurrency, LoggingUtil.getID(statement));
       return statement;
    }
 
    @Override
    public Map<String, Class<?>> getTypeMap() throws SQLException {
       Map<String, Class<?>> x = connection.getTypeMap();
-      logger.logf(level, "%s.getTypeMap() = %s", connectionID, x);
+      logger.trace("{}.getTypeMap() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
-      logger.logf(level, "%s.setTypeMap(%s)", connectionID, map);
+      logger.trace("{}.setTypeMap({})", connectionID, map);
       connection.setTypeMap(map);
    }
 
    @Override
    public void setHoldability(int holdability) throws SQLException {
-      logger.logf(level, "%s.setHoldability(%s)", connectionID, holdability);
+      logger.trace("{}.setHoldability({})", connectionID, holdability);
       connection.setHoldability(holdability);
    }
 
    @Override
    public int getHoldability() throws SQLException {
       int x = connection.getHoldability();
-      logger.logf(level, "%s.getHoldability() = %s", connectionID, x);
+      logger.trace("{}.getHoldability() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public Savepoint setSavepoint() throws SQLException {
       Savepoint x = connection.setSavepoint();
-      logger.logf(level, "%s.setSavepoint() = %s", connectionID, x);
+      logger.trace("{}.setSavepoint() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public Savepoint setSavepoint(String name) throws SQLException {
       Savepoint x = connection.setSavepoint(name);
-      logger.logf(level, "%s.setSavepoint(%s) = %s", connectionID, name, x);
+      logger.trace("{}.setSavepoint({}) = {}", connectionID, name, x);
       return x;
    }
 
    @Override
    public void rollback(Savepoint savepoint) throws SQLException {
-      logger.logf(level, "%s.rollback(%s)", connectionID, savepoint);
+      logger.trace("{}.rollback({})", connectionID, savepoint);
       connection.rollback(savepoint);
    }
 
    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
-      logger.logf(level, "%s.releaseSavepoint(%s)", connectionID, savepoint);
+      logger.trace("{}.releaseSavepoint({})", connectionID, savepoint);
       connection.releaseSavepoint(savepoint);
    }
 
@@ -268,7 +266,7 @@ public class LoggingConnection implements Connection {
                                     int resultSetConcurrency,
                                     int resultSetHoldability) throws SQLException {
       LoggingStatement statement = new LoggingStatement(connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability), logger);
-      logger.logf(level, "%s.createStatement(%s, %s, %s) = %s", connectionID, resultSetType, resultSetConcurrency, resultSetHoldability, statement.getStatementID());
+      logger.trace("{}.createStatement({}, {}, {}) = {}", connectionID, resultSetType, resultSetConcurrency, resultSetHoldability, statement.getStatementID());
       return statement;
    }
 
@@ -278,7 +276,7 @@ public class LoggingConnection implements Connection {
                                              int resultSetConcurrency,
                                              int resultSetHoldability) throws SQLException {
       LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability), logger);
-      logger.logf(level, "%s.prepareStatement(%s, %s, %s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, resultSetHoldability, statement.getStatementID());
+      logger.trace("{}.prepareStatement({}, {}, {}, {}) = {}", connectionID, sql, resultSetType, resultSetConcurrency, resultSetHoldability, statement.getStatementID());
       return statement;
    }
 
@@ -288,149 +286,149 @@ public class LoggingConnection implements Connection {
                                         int resultSetConcurrency,
                                         int resultSetHoldability) throws SQLException {
       CallableStatement statement = connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
-      logger.logf(level, "%s.prepareCall(%s, %s, %s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, resultSetHoldability, LoggingUtil.getID(statement));
+      logger.trace("{}.prepareCall({}, {}, {}, {}) = {}", connectionID, sql, resultSetType, resultSetConcurrency, resultSetHoldability, LoggingUtil.getID(statement));
       return statement;
    }
 
    @Override
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
       LoggingPreparedStatement preparedStatement = new LoggingPreparedStatement(connection.prepareStatement(sql, autoGeneratedKeys), logger);
-      logger.logf(level, "%s.prepareStatement(%s, %s) = %s", connectionID, sql, autoGeneratedKeys, preparedStatement.getStatementID());
+      logger.trace("{}.prepareStatement({}, {}) = {}", connectionID, sql, autoGeneratedKeys, preparedStatement.getStatementID());
       return preparedStatement;
    }
 
    @Override
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
       LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, columnIndexes), logger);
-      logger.logf(level, "%s.prepareStatement(%s, %s) = %s", connectionID, sql, Arrays.toString(columnIndexes), statement.getStatementID());
+      logger.trace("{}.prepareStatement({}, {}) = {}", connectionID, sql, Arrays.toString(columnIndexes), statement.getStatementID());
       return statement;
    }
 
    @Override
    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
       LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, columnNames), logger);
-      logger.logf(level, "%s.prepareStatement(%s, %s) = %s", connectionID, sql, Arrays.toString(columnNames), statement.getStatementID());
+      logger.trace("{}.prepareStatement({}, {}) = {}", connectionID, sql, Arrays.toString(columnNames), statement.getStatementID());
       return statement;
    }
 
    @Override
    public Clob createClob() throws SQLException {
       Clob x = connection.createClob();
-      logger.logf(level, "%s.createClob() = %s", connectionID, x);
+      logger.trace("{}.createClob() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public Blob createBlob() throws SQLException {
       Blob x = connection.createBlob();
-      logger.logf(level, "%s.createBlob() = %s", connectionID, x);
+      logger.trace("{}.createBlob() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public NClob createNClob() throws SQLException {
       NClob x = connection.createNClob();
-      logger.logf(level, "%s.createNClob() = %s", connectionID, x);
+      logger.trace("{}.createNClob() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public SQLXML createSQLXML() throws SQLException {
       SQLXML x = connection.createSQLXML();
-      logger.logf(level, "%s.createSQLXML() = %s", connectionID, x);
+      logger.trace("{}.createSQLXML() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public boolean isValid(int timeout) throws SQLException {
       boolean x = connection.isValid(timeout);
-      logger.logf(level, "%s.isValid(%s) = %s", connectionID, timeout, x);
+      logger.trace("{}.isValid({}) = {}", connectionID, timeout, x);
       return x;
    }
 
    @Override
    public void setClientInfo(String name, String value) throws SQLClientInfoException {
-      logger.logf(level, "%s.setClientInfo(%s, %s)", connectionID, name, value);
+      logger.trace("{}.setClientInfo({}, {})", connectionID, name, value);
       connection.setClientInfo(name, value);
    }
 
    @Override
    public void setClientInfo(Properties properties) throws SQLClientInfoException {
-      logger.logf(level, "%s.setClientInfo(%s)", connectionID, properties);
+      logger.trace("{}.setClientInfo({})", connectionID, properties);
       connection.setClientInfo(properties);
    }
 
    @Override
    public String getClientInfo(String name) throws SQLException {
       String x = connection.getClientInfo(name);
-      logger.logf(level, "%s.getClientInfo(%s) = %s", connectionID, name, x);
+      logger.trace("{}.getClientInfo({}) = {}", connectionID, name, x);
       return x;
    }
 
    @Override
    public Properties getClientInfo() throws SQLException {
       Properties x = connection.getClientInfo();
-      logger.logf(level, "%s.getClientInfo() = %s", connectionID, x);
+      logger.trace("{}.getClientInfo() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
       Array x = connection.createArrayOf(typeName, elements);
-      logger.logf(level, "%s.createArrayOf(%s, %s) = %s", connectionID, typeName, Arrays.toString(elements), x);
+      logger.trace("{}.createArrayOf({}, {}) = {}", connectionID, typeName, Arrays.toString(elements), x);
       return x;
    }
 
    @Override
    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
       Struct x = connection.createStruct(typeName, attributes);
-      logger.logf(level, "%s.createStruct(%s, %s) = %s", connectionID, typeName, Arrays.toString(attributes), x);
+      logger.trace("{}.createStruct({}, {}) = {}", connectionID, typeName, Arrays.toString(attributes), x);
       return x;
    }
 
    @Override
    public void setSchema(String schema) throws SQLException {
-      logger.logf(level, "%s.setSchema(%s)", connectionID, schema);
+      logger.trace("{}.setSchema({})", connectionID, schema);
       connection.setSchema(schema);
    }
 
    @Override
    public String getSchema() throws SQLException {
       String x = connection.getSchema();
-      logger.logf(level, "%s.getSchema() = %s", connectionID, x);
+      logger.trace("{}.getSchema() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public void abort(Executor executor) throws SQLException {
-      logger.logf(level, "%s.abort(%s)", connectionID, executor);
+      logger.trace("{}.abort({})", connectionID, executor);
       connection.abort(executor);
    }
 
    @Override
    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
-      logger.logf(level, "%s.setNetworkTimeout(%s, %d)", connectionID, executor, milliseconds);
+      logger.trace("{}.setNetworkTimeout({}, {})", connectionID, executor, milliseconds);
       connection.setNetworkTimeout(executor, milliseconds);
    }
 
    @Override
    public int getNetworkTimeout() throws SQLException {
       int x = connection.getNetworkTimeout();
-      logger.logf(level, "%s.getNetworkTimeout() = %s", connectionID, x);
+      logger.trace("{}.getNetworkTimeout() = {}", connectionID, x);
       return x;
    }
 
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
       T x = connection.unwrap(iface);
-      logger.logf(level, "%s.unwrap(%s) = %s", connectionID, iface, x);
+      logger.trace("{}.unwrap({}) = {}", connectionID, iface, x);
       return x;
    }
 
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
       boolean x = connection.isWrapperFor(iface);
-      logger.logf(level, "%s.isWrapperFor() = %s", connectionID, iface, x);
+      logger.trace("{}.isWrapperFor() = {}", connectionID, iface, x);
       return x;
    }
 }
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingPreparedStatement.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingPreparedStatement.java
index 4cf270d4bb..e1568eba33 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingPreparedStatement.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingPreparedStatement.java
@@ -39,7 +39,7 @@ import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.Calendar;
 
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
 
 public class LoggingPreparedStatement extends LoggingStatement implements PreparedStatement {
 
@@ -53,354 +53,354 @@ public class LoggingPreparedStatement extends LoggingStatement implements Prepar
    @Override
    public ResultSet executeQuery() throws SQLException {
       LoggingResultSet rs = new LoggingResultSet(preparedStatement.executeQuery(), logger);
-      logger.logf(level, "%s.executeQuery() = %s", statementID, rs.getResultSetID());
+      logger.trace("{}.executeQuery() = {}", statementID, rs.getResultSetID());
       return rs;
    }
 
    @Override
    public int executeUpdate() throws SQLException {
       int i = preparedStatement.executeUpdate();
-      logger.logf(level, "%s.executeUpdate() = %s", statementID, i);
+      logger.trace("{}.executeUpdate() = {}", statementID, i);
       return i;
    }
 
    @Override
    public void setNull(int parameterIndex, int sqlType) throws SQLException {
-      logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, sqlType);
+      logger.trace("{}.setNull({}, {})", statementID, parameterIndex, sqlType);
       preparedStatement.setNull(parameterIndex, sqlType);
    }
 
    @Override
    public void setBoolean(int parameterIndex, boolean x) throws SQLException {
-      logger.logf(level, "%s.setBoolean(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setBoolean({}, {})", statementID, parameterIndex, x);
       preparedStatement.setBoolean(parameterIndex, x);
    }
 
    @Override
    public void setByte(int parameterIndex, byte x) throws SQLException {
-      logger.logf(level, "%s.setByte(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setByte({}, {})", statementID, parameterIndex, x);
       preparedStatement.setByte(parameterIndex, x);
    }
 
    @Override
    public void setShort(int parameterIndex, short x) throws SQLException {
-      logger.logf(level, "%s.setShort(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setShort({}, {})", statementID, parameterIndex, x);
       preparedStatement.setShort(parameterIndex, x);
    }
 
    @Override
    public void setInt(int parameterIndex, int x) throws SQLException {
-      logger.logf(level, "%s.setInt(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setInt({}, {})", statementID, parameterIndex, x);
       preparedStatement.setInt(parameterIndex, x);
    }
 
    @Override
    public void setLong(int parameterIndex, long x) throws SQLException {
-      logger.logf(level, "%s.setLong(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setLong({}, {})", statementID, parameterIndex, x);
       preparedStatement.setLong(parameterIndex, x);
    }
 
    @Override
    public void setFloat(int parameterIndex, float x) throws SQLException {
-      logger.logf(level, "%s.setFloat(%d, %f)", statementID, parameterIndex, x);
+      logger.trace("{}.setFloat({}, {})", statementID, parameterIndex, x);
       preparedStatement.setFloat(parameterIndex, x);
    }
 
    @Override
    public void setDouble(int parameterIndex, double x) throws SQLException {
-      logger.logf(level, "%s.setDouble(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setDouble({}, {})", statementID, parameterIndex, x);
       preparedStatement.setDouble(parameterIndex, x);
    }
 
    @Override
    public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
-      logger.logf(level, "%s.setBigDecimal(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setBigDecimal({}, {})", statementID, parameterIndex, x);
       preparedStatement.setBigDecimal(parameterIndex, x);
    }
 
    @Override
    public void setString(int parameterIndex, String x) throws SQLException {
-      logger.logf(level, "%s.setString(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setString({}, {})", statementID, parameterIndex, x);
       preparedStatement.setString(parameterIndex, x);
    }
 
    @Override
    public void setBytes(int parameterIndex, byte[] x) throws SQLException {
-      logger.logf(level, "%s.setBytes(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setBytes({}, {})", statementID, parameterIndex, x);
       preparedStatement.setBytes(parameterIndex, x);
    }
 
    @Override
    public void setDate(int parameterIndex, Date x) throws SQLException {
-      logger.logf(level, "%s.setDate(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setDate({}, {})", statementID, parameterIndex, x);
       preparedStatement.setDate(parameterIndex, x);
    }
 
    @Override
    public void setTime(int parameterIndex, Time x) throws SQLException {
-      logger.logf(level, "%s.setTime(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setTime({}, {})", statementID, parameterIndex, x);
       preparedStatement.setTime(parameterIndex, x);
    }
 
    @Override
    public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
-      logger.logf(level, "%s.setTimestamp(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setTimestamp({}, {})", statementID, parameterIndex, x);
       preparedStatement.setTimestamp(parameterIndex, x);
    }
 
    @Override
    public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.setAsciiStream(%d, %s, %d)", statementID, parameterIndex, x, length);
+      logger.trace("{}.setAsciiStream({}, {}, {})", statementID, parameterIndex, x, length);
       preparedStatement.setAsciiStream(parameterIndex, x, length);
    }
 
    @Override
    public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.setUnicodeStream(%d, %s, %d)", statementID, parameterIndex, x, length);
+      logger.trace("{}.setUnicodeStream({}, {}, {})", statementID, parameterIndex, x, length);
       preparedStatement.setUnicodeStream(parameterIndex, x, length);
    }
 
    @Override
    public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.setBinaryStream(%d, %s, %d)", statementID, parameterIndex, x, length);
+      logger.trace("{}.setBinaryStream({}, {}, {})", statementID, parameterIndex, x, length);
       preparedStatement.setBinaryStream(parameterIndex, x, length);
    }
 
    @Override
    public void clearParameters() throws SQLException {
-      logger.logf(level, "%s.clearParameters()", statementID);
+      logger.trace("{}.clearParameters()", statementID);
       preparedStatement.clearParameters();
    }
 
    @Override
    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
-      logger.logf(level, "%s.setObject(%d, %s, %d)", statementID, parameterIndex, x, targetSqlType);
+      logger.trace("{}.setObject({}, {}, {})", statementID, parameterIndex, x, targetSqlType);
       preparedStatement.setObject(parameterIndex, x, targetSqlType);
    }
 
    @Override
    public void setObject(int parameterIndex, Object x) throws SQLException {
-      logger.logf(level, "%s.setObject(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setObject({}, {})", statementID, parameterIndex, x);
       preparedStatement.setObject(parameterIndex, x);
    }
 
    @Override
    public boolean execute() throws SQLException {
       boolean b = preparedStatement.execute();
-      logger.logf(level, "%s.execute() = %s", statementID, b);
+      logger.trace("{}.execute() = {}", statementID, b);
       return b;
    }
 
    @Override
    public void addBatch() throws SQLException {
-      logger.logf(level, "%s.addBatch()", statementID);
+      logger.trace("{}.addBatch()", statementID);
       preparedStatement.addBatch();
    }
 
    @Override
    public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
-      logger.logf(level, "%s.setCharacterStream(%d, %s, %d)", statementID, parameterIndex, reader, length);
+      logger.trace("{}.setCharacterStream({}, {}, {})", statementID, parameterIndex, reader, length);
       preparedStatement.setCharacterStream(parameterIndex, reader, length);
    }
 
    @Override
    public void setRef(int parameterIndex, Ref x) throws SQLException {
-      logger.logf(level, "%s.setRef(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setRef({}, {})", statementID, parameterIndex, x);
       preparedStatement.setRef(parameterIndex, x);
    }
 
    @Override
    public void setBlob(int parameterIndex, Blob x) throws SQLException {
-      logger.logf(level, "%s.setBlob(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setBlob({}, {})", statementID, parameterIndex, x);
       preparedStatement.setBlob(parameterIndex, x);
    }
 
    @Override
    public void setClob(int parameterIndex, Clob x) throws SQLException {
-      logger.logf(level, "%s.setClob(%d, %x)", statementID, parameterIndex, x);
+      logger.trace("{}.setClob({}, {})", statementID, parameterIndex, x);
       preparedStatement.setClob(parameterIndex, x);
    }
 
    @Override
    public void setArray(int parameterIndex, Array x) throws SQLException {
-      logger.logf(level, "%s.setArray(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setArray({}, {})", statementID, parameterIndex, x);
       preparedStatement.setArray(parameterIndex, x);
    }
 
    @Override
    public ResultSetMetaData getMetaData() throws SQLException {
       ResultSetMetaData resultSetMetaData = preparedStatement.getMetaData();
-      logger.logf(level, "%s.getMetaData() = %s", statementID, LoggingUtil.getID(resultSetMetaData));
+      logger.trace("{}.getMetaData() = {}", statementID, LoggingUtil.getID(resultSetMetaData));
       return resultSetMetaData;
    }
 
    @Override
    public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
-      logger.logf(level, "%s.setDate(%d, %s, %s)", statementID, parameterIndex, x, cal);
+      logger.trace("{}.setDate({}, {}, {})", statementID, parameterIndex, x, cal);
       preparedStatement.setDate(parameterIndex, x, cal);
    }
 
    @Override
    public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
-      logger.logf(level, "%s.setTime(%d, %s, %s)", statementID, parameterIndex, x, cal);
+      logger.trace("{}.setTime({}, {}, {})", statementID, parameterIndex, x, cal);
       preparedStatement.setTime(parameterIndex, x, cal);
    }
 
    @Override
    public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
-      logger.logf(level, "%s.setTimestamp(%d, %s, %s)", statementID, parameterIndex, x, cal);
+      logger.trace("{}.setTimestamp({}, {}, {})", statementID, parameterIndex, x, cal);
       preparedStatement.setTimestamp(parameterIndex, x, cal);
    }
 
    @Override
    public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
-      logger.logf(level, "%s.setNull(%d, %d, %s)", statementID, parameterIndex, sqlType, typeName);
+      logger.trace("{}.setNull({}, {}, {})", statementID, parameterIndex, sqlType, typeName);
       preparedStatement.setNull(parameterIndex, sqlType, typeName);
    }
 
    @Override
    public void setURL(int parameterIndex, URL x) throws SQLException {
-      logger.logf(level, "%s.setURL(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setURL({}, {})", statementID, parameterIndex, x);
       preparedStatement.setURL(parameterIndex, x);
    }
 
    @Override
    public ParameterMetaData getParameterMetaData() throws SQLException {
       ParameterMetaData x = preparedStatement.getParameterMetaData();
-      logger.logf(level, "%s.getParameterMetaData() = %s", statementID, x);
+      logger.trace("{}.getParameterMetaData() = {}", statementID, x);
       return x;
    }
 
    @Override
    public void setRowId(int parameterIndex, RowId x) throws SQLException {
-      logger.logf(level, "%s.setRowId(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setRowId({}, {})", statementID, parameterIndex, x);
       preparedStatement.setRowId(parameterIndex, x);
    }
 
    @Override
    public void setNString(int parameterIndex, String value) throws SQLException {
-      logger.logf(level, "%s.setNString(%d, %s)", statementID, parameterIndex, value);
+      logger.trace("{}.setNString({}, {})", statementID, parameterIndex, value);
       preparedStatement.setNString(parameterIndex, value);
    }
 
    @Override
    public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
-      logger.logf(level, "%s.setNCharacterStream(%d, %s, %d)", statementID, parameterIndex, value, length);
+      logger.trace("{}.setNCharacterStream({}, {}, {})", statementID, parameterIndex, value, length);
       preparedStatement.setNCharacterStream(parameterIndex, value, length);
    }
 
    @Override
    public void setNClob(int parameterIndex, NClob value) throws SQLException {
-      logger.logf(level, "%s.setNClob(%d, %s)", statementID, parameterIndex, value);
+      logger.trace("{}.setNClob({}, {})", statementID, parameterIndex, value);
       preparedStatement.setNClob(parameterIndex, value);
    }
 
    @Override
    public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.setClob(%d, %s, %s)", statementID, parameterIndex, reader, length);
+      logger.trace("{}.setClob({}, {}, {})", statementID, parameterIndex, reader, length);
       preparedStatement.setClob(parameterIndex, reader, length);
    }
 
    @Override
    public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
-      logger.logf(level, "%s.setBlob(%d, %s, %d)", statementID, parameterIndex, inputStream, length);
+      logger.trace("{}.setBlob({}, {}, {})", statementID, parameterIndex, inputStream, length);
       preparedStatement.setBlob(parameterIndex, inputStream, length);
    }
 
    @Override
    public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.setNClob(%d, %s, %d)", statementID, parameterIndex, reader, length);
+      logger.trace("{}.setNClob({}, {}, {})", statementID, parameterIndex, reader, length);
       preparedStatement.setNClob(parameterIndex, reader, length);
    }
 
    @Override
    public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
-      logger.logf(level, "%s.setSQLXML(%d, %s)", statementID, parameterIndex, xmlObject);
+      logger.trace("{}.setSQLXML({}, {})", statementID, parameterIndex, xmlObject);
       preparedStatement.setSQLXML(parameterIndex, xmlObject);
    }
 
    @Override
    public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
-      logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setNull({}, {})", statementID, parameterIndex, x);
       preparedStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
    }
 
    @Override
    public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
-      logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setNull({}, {})", statementID, parameterIndex, x);
       preparedStatement.setAsciiStream(parameterIndex, x, length);
    }
 
    @Override
    public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
-      logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setNull({}, {})", statementID, parameterIndex, x);
       preparedStatement.setBinaryStream(parameterIndex, x, length);
    }
 
    @Override
    public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.setCharacterStream(%d, %s, %d)", statementID, parameterIndex, reader, length);
+      logger.trace("{}.setCharacterStream({}, {}, {})", statementID, parameterIndex, reader, length);
       preparedStatement.setCharacterStream(parameterIndex, reader, length);
    }
 
    @Override
    public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
-      logger.logf(level, "%s.setAsciiStream(%d, %d)", statementID, parameterIndex, x);
+      logger.trace("{}.setAsciiStream({}, {})", statementID, parameterIndex, x);
       preparedStatement.setAsciiStream(parameterIndex, x);
    }
 
    @Override
    public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
-      logger.logf(level, "%s.setBinaryStream(%d, %s)", statementID, parameterIndex, x);
+      logger.trace("{}.setBinaryStream({}, {})", statementID, parameterIndex, x);
       preparedStatement.setBinaryStream(parameterIndex, x);
    }
 
    @Override
    public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
-      logger.logf(level, "%s.setCharacterStream(%d, %s)", statementID, parameterIndex, reader);
+      logger.trace("{}.setCharacterStream({}, {})", statementID, parameterIndex, reader);
       preparedStatement.setCharacterStream(parameterIndex, reader);
    }
 
    @Override
    public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
-      logger.logf(level, "%s.setNCharacterStream(%d, %s)", statementID, parameterIndex, value);
+      logger.trace("{}.setNCharacterStream({}, {})", statementID, parameterIndex, value);
       preparedStatement.setNCharacterStream(parameterIndex, value);
    }
 
    @Override
    public void setClob(int parameterIndex, Reader reader) throws SQLException {
-      logger.logf(level, "%s.setClob(%d, %s)", statementID, parameterIndex, reader);
+      logger.trace("{}.setClob({}, {})", statementID, parameterIndex, reader);
       preparedStatement.setClob(parameterIndex, reader);
    }
 
    @Override
    public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
-      logger.logf(level, "%s.setBlob(%d, %s)", statementID, parameterIndex, inputStream);
+      logger.trace("{}.setBlob({}, {})", statementID, parameterIndex, inputStream);
       preparedStatement.setBlob(parameterIndex, inputStream);
    }
 
    @Override
    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
-      logger.logf(level, "%s.setNClob(%d, %s)", statementID, parameterIndex, reader);
+      logger.trace("{}.setNClob({}, {})", statementID, parameterIndex, reader);
       preparedStatement.setNClob(parameterIndex, reader);
    }
 
    @Override
    public void setObject(int parameterIndex, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException {
-      logger.logf(level, "%s.setObject(%d, %s, %s, %d)", statementID, parameterIndex, x, targetSqlType, scaleOrLength);
+      logger.trace("{}.setObject({}, {}, {}, {})", statementID, parameterIndex, x, targetSqlType, scaleOrLength);
       preparedStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
    }
 
    @Override
    public void setObject(int parameterIndex, Object x, SQLType targetSqlType) throws SQLException {
-      logger.logf(level, "%s.setObject(%d, %s, %d)", statementID, parameterIndex, x, targetSqlType);
+      logger.trace("{}.setObject({}, {}, {})", statementID, parameterIndex, x, targetSqlType);
       preparedStatement.setObject(parameterIndex, x, targetSqlType);
    }
 
    @Override
    public long executeLargeUpdate() throws SQLException {
       long l = preparedStatement.executeLargeUpdate();
-      logger.logf(level, "%s.executeLargeUpdate() = %s", statementID, l);
+      logger.trace("{}.executeLargeUpdate() = {}", statementID, l);
       return l;
    }
 }
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingResultSet.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingResultSet.java
index 05dcac429c..ba27f674a6 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingResultSet.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingResultSet.java
@@ -41,7 +41,8 @@ import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Map;
 
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+
 
 public class LoggingResultSet implements ResultSet {
 
@@ -51,8 +52,6 @@ public class LoggingResultSet implements ResultSet {
 
    private final Logger logger;
 
-   private static final Logger.Level level = Logger.Level.TRACE;
-
    public LoggingResultSet(ResultSet resultSet, Logger logger) {
       this.resultSet = resultSet;
       this.logger = logger;
@@ -70,1234 +69,1234 @@ public class LoggingResultSet implements ResultSet {
    @Override
    public boolean next() throws SQLException {
       boolean b = resultSet.next();
-      logger.logf(level, "%s.next() = %s", resultSetID, b);
+      logger.trace("{}.next() = {}", resultSetID, b);
       return b;
    }
 
    @Override
    public void close() throws SQLException {
-      logger.logf(level, "%s.close()", resultSetID);
+      logger.trace("{}.close()", resultSetID);
       resultSet.close();
    }
 
    @Override
    public boolean wasNull() throws SQLException {
       boolean b = resultSet.wasNull();
-      logger.logf(level, "%s.wasNull() = %s", resultSetID, b);
+      logger.trace("{}.wasNull() = {}", resultSetID, b);
       return b;
    }
 
    @Override
    public String getString(int columnIndex) throws SQLException {
       String x = resultSet.getString(columnIndex);
-      logger.logf(level, "%s.getString(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getString({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public boolean getBoolean(int columnIndex) throws SQLException {
       boolean x = resultSet.getBoolean(columnIndex);
-      logger.logf(level, "%s.getBoolean(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getBoolean({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public byte getByte(int columnIndex) throws SQLException {
       byte x = resultSet.getByte(columnIndex);
-      logger.logf(level, "%s.getByte(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getByte({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public short getShort(int columnIndex) throws SQLException {
       short x = resultSet.getShort(columnIndex);
-      logger.logf(level, "%s.getShort(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getShort({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public int getInt(int columnIndex) throws SQLException {
       int x = resultSet.getInt(columnIndex);
-      logger.logf(level, "%s.getInt(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getInt({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public long getLong(int columnIndex) throws SQLException {
       long x = resultSet.getLong(columnIndex);
-      logger.logf(level, "%s.getLong(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getLong({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public float getFloat(int columnIndex) throws SQLException {
       float x = resultSet.getFloat(columnIndex);
-      logger.logf(level, "%s.getFloat(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getFloat({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public double getDouble(int columnIndex) throws SQLException {
       double x = resultSet.getDouble(columnIndex);
-      logger.logf(level, "%s.getDouble(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getDouble({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
       BigDecimal x = resultSet.getBigDecimal(columnIndex);
-      logger.logf(level, "%s.getBigDecimal(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getBigDecimal({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public byte[] getBytes(int columnIndex) throws SQLException {
       byte[] x = resultSet.getBytes(columnIndex);
-      logger.logf(level, "%s.getBytes(%s) = %s", resultSetID, columnIndex, Arrays.toString(x));
+      logger.trace("{}.getBytes({}) = {}", resultSetID, columnIndex, Arrays.toString(x));
       return x;
    }
 
    @Override
    public Date getDate(int columnIndex) throws SQLException {
       Date x = resultSet.getDate(columnIndex);
-      logger.logf(level, "%s.getDate(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getDate({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Time getTime(int columnIndex) throws SQLException {
       Time x = resultSet.getTime(columnIndex);
-      logger.logf(level, "%s.getTime(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getTime({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Timestamp getTimestamp(int columnIndex) throws SQLException {
       Timestamp x = resultSet.getTimestamp(columnIndex);
-      logger.logf(level, "%s.getTimestamp(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getTimestamp({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public InputStream getAsciiStream(int columnIndex) throws SQLException {
       InputStream x = resultSet.getAsciiStream(columnIndex);
-      logger.logf(level, "%s.getAsciiStream(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getAsciiStream({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public InputStream getUnicodeStream(int columnIndex) throws SQLException {
       InputStream x = resultSet.getUnicodeStream(columnIndex);
-      logger.logf(level, "%s.getUnicodeStream(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getUnicodeStream({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public InputStream getBinaryStream(int columnIndex) throws SQLException {
       InputStream x = resultSet.getBinaryStream(columnIndex);
-      logger.logf(level, "%s.getBinaryStream(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getBinaryStream({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public String getString(String columnLabel) throws SQLException {
       String x = resultSet.getString(columnLabel);
-      logger.logf(level, "%s.getString(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getString({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public boolean getBoolean(String columnLabel) throws SQLException {
       boolean x = resultSet.getBoolean(columnLabel);
-      logger.logf(level, "%s.getBoolean(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getBoolean({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public byte getByte(String columnLabel) throws SQLException {
       byte x = resultSet.getByte(columnLabel);
-      logger.logf(level, "%s.getByte(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getByte({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public short getShort(String columnLabel) throws SQLException {
       short x = resultSet.getShort(columnLabel);
-      logger.logf(level, "%s.getShort(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getShort({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public int getInt(String columnLabel) throws SQLException {
       int x = resultSet.getInt(columnLabel);
-      logger.logf(level, "%s.getInt(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getInt({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public long getLong(String columnLabel) throws SQLException {
       long x = resultSet.getLong(columnLabel);
-      logger.logf(level, "%s.getLong(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getLong({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public float getFloat(String columnLabel) throws SQLException {
       float x = resultSet.getFloat(columnLabel);
-      logger.logf(level, "%s.getFloat(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getFloat({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public double getDouble(String columnLabel) throws SQLException {
       double x = resultSet.getDouble(columnLabel);
-      logger.logf(level, "%s.getDouble(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getDouble({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
       BigDecimal x = resultSet.getBigDecimal(columnLabel);
-      logger.logf(level, "%s.getBigDecimal(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getBigDecimal({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public byte[] getBytes(String columnLabel) throws SQLException {
       byte[] x = resultSet.getBytes(columnLabel);
-      logger.logf(level, "%s.getBytes(%s) = %s", resultSetID, columnLabel, Arrays.toString(x));
+      logger.trace("{}.getBytes({}) = {}", resultSetID, columnLabel, Arrays.toString(x));
       return x;
    }
 
    @Override
    public Date getDate(String columnLabel) throws SQLException {
       Date x = resultSet.getDate(columnLabel);
-      logger.logf(level, "%s.getDate(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getDate({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public Time getTime(String columnLabel) throws SQLException {
       Time x = resultSet.getTime(columnLabel);
-      logger.logf(level, "%s.getTime(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getTime({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public Timestamp getTimestamp(String columnLabel) throws SQLException {
       Timestamp x = resultSet.getTimestamp(columnLabel);
-      logger.logf(level, "%s.getTimestamp(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getTimestamp({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public InputStream getAsciiStream(String columnLabel) throws SQLException {
       InputStream x = resultSet.getAsciiStream(columnLabel);
-      logger.logf(level, "%s.getAsciiStream(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getAsciiStream({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public InputStream getUnicodeStream(String columnLabel) throws SQLException {
       InputStream x = resultSet.getUnicodeStream(columnLabel);
-      logger.logf(level, "%s.getUnicodeStream(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getUnicodeStream({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public InputStream getBinaryStream(String columnLabel) throws SQLException {
       InputStream x = resultSet.getBinaryStream(columnLabel);
-      logger.logf(level, "%s.getBinaryStream(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getBinaryStream({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public SQLWarning getWarnings() throws SQLException {
       SQLWarning x = resultSet.getWarnings();
-      logger.logf(level, "%s.getWarnings) = %s", resultSetID, x);
+      logger.trace("{}.getWarnings) = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public void clearWarnings() throws SQLException {
-      logger.logf(level, "%s.clearWarnings()", resultSetID);
+      logger.trace("{}.clearWarnings()", resultSetID);
       resultSet.clearWarnings();
    }
 
    @Override
    public String getCursorName() throws SQLException {
       String x = resultSet.getCursorName();
-      logger.logf(level, "%s.getCursorName() = %s", resultSetID, x);
+      logger.trace("{}.getCursorName() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public ResultSetMetaData getMetaData() throws SQLException {
       ResultSetMetaData x = resultSet.getMetaData();
-      logger.logf(level, "%s.getMetaData() = %s", resultSetID, x);
+      logger.trace("{}.getMetaData() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public Object getObject(int columnIndex) throws SQLException {
       String x = resultSet.getString(columnIndex);
-      logger.logf(level, "%s.getString(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getString({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Object getObject(String columnLabel) throws SQLException {
       Object x = resultSet.getObject(columnLabel);
-      logger.logf(level, "%s.getObject(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getObject({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public int findColumn(String columnLabel) throws SQLException {
       int x = resultSet.findColumn(columnLabel);
-      logger.logf(level, "%s.findColumn(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.findColumn({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public Reader getCharacterStream(int columnIndex) throws SQLException {
       Reader x = resultSet.getCharacterStream(columnIndex);
-      logger.logf(level, "%s.getCharacterStream(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getCharacterStream({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Reader getCharacterStream(String columnLabel) throws SQLException {
       Reader x = resultSet.getCharacterStream(columnLabel);
-      logger.logf(level, "%s.getCharacterStream(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getCharacterStream({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
       BigDecimal x = resultSet.getBigDecimal(columnIndex);
-      logger.logf(level, "%s.getBigDecimal(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getBigDecimal({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
       BigDecimal x = resultSet.getBigDecimal(columnLabel);
-      logger.logf(level, "%s.getBigDecimal(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getBigDecimal({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public boolean isBeforeFirst() throws SQLException {
       boolean x = resultSet.isBeforeFirst();
-      logger.logf(level, "%s.isBeforeFirst() = %s", resultSetID, x);
+      logger.trace("{}.isBeforeFirst() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean isAfterLast() throws SQLException {
       boolean x = resultSet.isAfterLast();
-      logger.logf(level, "%s.isAfterLast() = %s", resultSetID, x);
+      logger.trace("{}.isAfterLast() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean isFirst() throws SQLException {
       boolean x = resultSet.isFirst();
-      logger.logf(level, "%s.isFirst() = %s", resultSetID, x);
+      logger.trace("{}.isFirst() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean isLast() throws SQLException {
       boolean x = resultSet.isLast();
-      logger.logf(level, "%s.isLast() = %s", resultSetID, x);
+      logger.trace("{}.isLast() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public void beforeFirst() throws SQLException {
-      logger.logf(level, "%s.beforeFirst()", resultSetID);
+      logger.trace("{}.beforeFirst()", resultSetID);
       resultSet.beforeFirst();
    }
 
    @Override
    public void afterLast() throws SQLException {
-      logger.logf(level, "%s.afterLast()", resultSetID);
+      logger.trace("{}.afterLast()", resultSetID);
       resultSet.afterLast();
    }
 
    @Override
    public boolean first() throws SQLException {
       boolean x = resultSet.first();
-      logger.logf(level, "%s.first() = %s", resultSetID, x);
+      logger.trace("{}.first() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean last() throws SQLException {
       boolean x = resultSet.last();
-      logger.logf(level, "%s.last() = %s", resultSetID, x);
+      logger.trace("{}.last() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public int getRow() throws SQLException {
       int x = resultSet.getRow();
-      logger.logf(level, "%s.getRow() = %s", resultSetID, x);
+      logger.trace("{}.getRow() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean absolute(int row) throws SQLException {
       boolean x = resultSet.absolute(row);
-      logger.logf(level, "%s.absolute(%s) = %s", resultSetID, row, x);
+      logger.trace("{}.absolute({}) = {}", resultSetID, row, x);
       return x;
    }
 
    @Override
    public boolean relative(int rows) throws SQLException {
       boolean x = resultSet.relative(rows);
-      logger.logf(level, "%s.relative(%s) = %s", resultSetID, rows, x);
+      logger.trace("{}.relative({}) = {}", resultSetID, rows, x);
       return x;
    }
 
    @Override
    public boolean previous() throws SQLException {
       boolean x = resultSet.previous();
-      logger.logf(level, "%s.previous() = %s", resultSetID, x);
+      logger.trace("{}.previous() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public void setFetchDirection(int direction) throws SQLException {
-      logger.logf(level, "%s.setFetchDirection(%s)", resultSetID, direction);
+      logger.trace("{}.setFetchDirection({})", resultSetID, direction);
       resultSet.setFetchDirection(direction);
    }
 
    @Override
    public int getFetchDirection() throws SQLException {
       int x = resultSet.getFetchDirection();
-      logger.logf(level, "%s.getFetchDirection() = %s", resultSetID, x);
+      logger.trace("{}.getFetchDirection() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public void setFetchSize(int rows) throws SQLException {
-      logger.logf(level, "%s.setFetchSize(%s)", resultSetID, rows);
+      logger.trace("{}.setFetchSize({})", resultSetID, rows);
       resultSet.setFetchSize(rows);
    }
 
    @Override
    public int getFetchSize() throws SQLException {
       int x = resultSet.getFetchSize();
-      logger.logf(level, "%s.getFetchSize() = %s", resultSetID, x);
+      logger.trace("{}.getFetchSize() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public int getType() throws SQLException {
       int x = resultSet.getType();
-      logger.logf(level, "%s.getType() = %s", resultSetID, x);
+      logger.trace("{}.getType() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public int getConcurrency() throws SQLException {
       int x = resultSet.getConcurrency();
-      logger.logf(level, "%s.getConcurrency() = %s", resultSetID, x);
+      logger.trace("{}.getConcurrency() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean rowUpdated() throws SQLException {
       boolean x = resultSet.rowUpdated();
-      logger.logf(level, "%s.rowUpdated() = %s", resultSetID, x);
+      logger.trace("{}.rowUpdated() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean rowInserted() throws SQLException {
       boolean x = resultSet.rowInserted();
-      logger.logf(level, "%s.rowInserted() = %s", resultSetID, x);
+      logger.trace("{}.rowInserted() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean rowDeleted() throws SQLException {
       boolean x = resultSet.rowDeleted();
-      logger.logf(level, "%s.rowDeleted() = %s", resultSetID, x);
+      logger.trace("{}.rowDeleted() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public void updateNull(int columnIndex) throws SQLException {
-      logger.logf(level, "%s.updateNull(%s)", resultSetID, columnIndex);
+      logger.trace("{}.updateNull({})", resultSetID, columnIndex);
       resultSet.updateNull(columnIndex);
    }
 
    @Override
    public void updateBoolean(int columnIndex, boolean x) throws SQLException {
-      logger.logf(level, "%s.updateBoolean(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateBoolean({}, {})", resultSetID, columnIndex, x);
       resultSet.updateBoolean(columnIndex, x);
    }
 
    @Override
    public void updateByte(int columnIndex, byte x) throws SQLException {
-      logger.logf(level, "%s.updateByte(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateByte({}, {})", resultSetID, columnIndex, x);
       resultSet.updateByte(columnIndex, x);
    }
 
    @Override
    public void updateShort(int columnIndex, short x) throws SQLException {
-      logger.logf(level, "%s.updateShort(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateShort({}, {})", resultSetID, columnIndex, x);
       resultSet.updateShort(columnIndex, x);
    }
 
    @Override
    public void updateInt(int columnIndex, int x) throws SQLException {
-      logger.logf(level, "%s.updateInt(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateInt({}, {})", resultSetID, columnIndex, x);
       resultSet.updateInt(columnIndex, x);
    }
 
    @Override
    public void updateLong(int columnIndex, long x) throws SQLException {
-      logger.logf(level, "%s.updateLong(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateLong({}, {})", resultSetID, columnIndex, x);
       resultSet.updateLong(columnIndex, x);
    }
 
    @Override
    public void updateFloat(int columnIndex, float x) throws SQLException {
-      logger.logf(level, "%s.updateFloat(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateFloat({}, {})", resultSetID, columnIndex, x);
       resultSet.updateFloat(columnIndex, x);
    }
 
    @Override
    public void updateDouble(int columnIndex, double x) throws SQLException {
-      logger.logf(level, "%s.updateDouble(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateDouble({}, {})", resultSetID, columnIndex, x);
       resultSet.updateDouble(columnIndex, x);
    }
 
    @Override
    public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
-      logger.logf(level, "%s.updateBigDecimal(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateBigDecimal({}, {})", resultSetID, columnIndex, x);
       resultSet.updateBigDecimal(columnIndex, x);
    }
 
    @Override
    public void updateString(int columnIndex, String x) throws SQLException {
-      logger.logf(level, "%s.updateString(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateString({}, {})", resultSetID, columnIndex, x);
       resultSet.updateString(columnIndex, x);
    }
 
    @Override
    public void updateBytes(int columnIndex, byte[] x) throws SQLException {
-      logger.logf(level, "%s.updateBytes(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateBytes({}, {})", resultSetID, columnIndex, x);
       resultSet.updateBytes(columnIndex, x);
    }
 
    @Override
    public void updateDate(int columnIndex, Date x) throws SQLException {
-      logger.logf(level, "%s.updateDate(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateDate({}, {})", resultSetID, columnIndex, x);
       resultSet.updateDate(columnIndex, x);
    }
 
    @Override
    public void updateTime(int columnIndex, Time x) throws SQLException {
-      logger.logf(level, "%s.updateTime(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateTime({}, {})", resultSetID, columnIndex, x);
       resultSet.updateTime(columnIndex, x);
    }
 
    @Override
    public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
-      logger.logf(level, "%s.updateTimestamp(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateTimestamp({}, {})", resultSetID, columnIndex, x);
       resultSet.updateTimestamp(columnIndex, x);
    }
 
    @Override
    public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.updateAsciiStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateAsciiStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateAsciiStream(columnIndex, x, length);
    }
 
    @Override
    public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.updateBinaryStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateBinaryStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateBinaryStream(columnIndex, x, length);
    }
 
    @Override
    public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
-      logger.logf(level, "%s.updateCharacterStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateCharacterStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateCharacterStream(columnIndex, x, length);
    }
 
    @Override
    public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s, %s)", resultSetID, columnIndex, x, scaleOrLength);
+      logger.trace("{}.updateObject({}, {}, {})", resultSetID, columnIndex, x, scaleOrLength);
       resultSet.updateObject(columnIndex, x, scaleOrLength);
    }
 
    @Override
    public void updateObject(int columnIndex, Object x) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateObject({}, {})", resultSetID, columnIndex, x);
       resultSet.updateObject(columnIndex, x);
    }
 
    @Override
    public void updateNull(String columnLabel) throws SQLException {
-      logger.logf(level, "%s.updateNull(%s)", resultSetID, columnLabel);
+      logger.trace("{}.updateNull({})", resultSetID, columnLabel);
       resultSet.updateNull(columnLabel);
    }
 
    @Override
    public void updateBoolean(String columnLabel, boolean x) throws SQLException {
-      logger.logf(level, "%s.updateBoolean(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateBoolean({}, {})", resultSetID, columnLabel, x);
       resultSet.updateBoolean(columnLabel, x);
    }
 
    @Override
    public void updateByte(String columnLabel, byte x) throws SQLException {
-      logger.logf(level, "%s.updateByte(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateByte({}, {})", resultSetID, columnLabel, x);
       resultSet.updateByte(columnLabel, x);
    }
 
    @Override
    public void updateShort(String columnLabel, short x) throws SQLException {
-      logger.logf(level, "%s.updateShort(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateShort({}, {})", resultSetID, columnLabel, x);
       resultSet.updateShort(columnLabel, x);
    }
 
    @Override
    public void updateInt(String columnLabel, int x) throws SQLException {
-      logger.logf(level, "%s.updateInt(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateInt({}, {})", resultSetID, columnLabel, x);
       resultSet.updateInt(columnLabel, x);
    }
 
    @Override
    public void updateLong(String columnLabel, long x) throws SQLException {
-      logger.logf(level, "%s.updateLong(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateLong({}, {})", resultSetID, columnLabel, x);
       resultSet.updateLong(columnLabel, x);
    }
 
    @Override
    public void updateFloat(String columnLabel, float x) throws SQLException {
-      logger.logf(level, "%s.updateFloat(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateFloat({}, {})", resultSetID, columnLabel, x);
       resultSet.updateFloat(columnLabel, x);
    }
 
    @Override
    public void updateDouble(String columnLabel, double x) throws SQLException {
-      logger.logf(level, "%s.updateDouble(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateDouble({}, {})", resultSetID, columnLabel, x);
       resultSet.updateDouble(columnLabel, x);
    }
 
    @Override
    public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
-      logger.logf(level, "%s.updateBigDecimal(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateBigDecimal({}, {})", resultSetID, columnLabel, x);
       resultSet.updateBigDecimal(columnLabel, x);
    }
 
    @Override
    public void updateString(String columnLabel, String x) throws SQLException {
-      logger.logf(level, "%s.updateString(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateString({}, {})", resultSetID, columnLabel, x);
       resultSet.updateString(columnLabel, x);
    }
 
    @Override
    public void updateBytes(String columnLabel, byte[] x) throws SQLException {
-      logger.logf(level, "%s.updateBytes(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateBytes({}, {})", resultSetID, columnLabel, x);
       resultSet.updateBytes(columnLabel, x);
    }
 
    @Override
    public void updateDate(String columnLabel, Date x) throws SQLException {
-      logger.logf(level, "%s.updateDate(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateDate({}, {})", resultSetID, columnLabel, x);
       resultSet.updateDate(columnLabel, x);
    }
 
    @Override
    public void updateTime(String columnLabel, Time x) throws SQLException {
-      logger.logf(level, "%s.updateTime(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateTime({}, {})", resultSetID, columnLabel, x);
       resultSet.updateTime(columnLabel, x);
    }
 
    @Override
    public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
-      logger.logf(level, "%s.updateTimestamp(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateTimestamp({}, {})", resultSetID, columnLabel, x);
       resultSet.updateTimestamp(columnLabel, x);
    }
 
    @Override
    public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.updateAsciiStream(%s, %s, %s)", resultSetID, columnLabel, x, length);
+      logger.trace("{}.updateAsciiStream({}, {}, {})", resultSetID, columnLabel, x, length);
       resultSet.updateAsciiStream(columnLabel, x, length);
    }
 
    @Override
    public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
-      logger.logf(level, "%s.updateBinaryStream(%s, %s, %s)", resultSetID, columnLabel, x, length);
+      logger.trace("{}.updateBinaryStream({}, {}, {})", resultSetID, columnLabel, x, length);
       resultSet.updateBinaryStream(columnLabel, x, length);
    }
 
    @Override
    public void updateCharacterStream(String columnLabel, Reader x, int length) throws SQLException {
-      logger.logf(level, "%s.updateCharacterStream(%s, %s, %s)", resultSetID, columnLabel, x, length);
+      logger.trace("{}.updateCharacterStream({}, {}, {})", resultSetID, columnLabel, x, length);
       resultSet.updateCharacterStream(columnLabel, x, length);
    }
 
    @Override
    public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s, %s)", resultSetID, columnLabel, x, scaleOrLength);
+      logger.trace("{}.updateObject({}, {}, {})", resultSetID, columnLabel, x, scaleOrLength);
       resultSet.updateObject(columnLabel, x, scaleOrLength);
    }
 
    @Override
    public void updateObject(String columnLabel, Object x) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateObject({}, {})", resultSetID, columnLabel, x);
       resultSet.updateObject(columnLabel, x);
    }
 
    @Override
    public void insertRow() throws SQLException {
-      logger.logf(level, "%s.insertRow()", resultSetID);
+      logger.trace("{}.insertRow()", resultSetID);
       resultSet.insertRow();
    }
 
    @Override
    public void updateRow() throws SQLException {
-      logger.logf(level, "%s.updateRow()", resultSetID);
+      logger.trace("{}.updateRow()", resultSetID);
       resultSet.updateRow();
    }
 
    @Override
    public void deleteRow() throws SQLException {
-      logger.logf(level, "%s.deleteRow()", resultSetID);
+      logger.trace("{}.deleteRow()", resultSetID);
       resultSet.deleteRow();
    }
 
    @Override
    public void refreshRow() throws SQLException {
-      logger.logf(level, "%s.refreshRow()", resultSetID);
+      logger.trace("{}.refreshRow()", resultSetID);
       resultSet.refreshRow();
    }
 
    @Override
    public void cancelRowUpdates() throws SQLException {
-      logger.logf(level, "%s.cancelRowUpdates()", resultSetID);
+      logger.trace("{}.cancelRowUpdates()", resultSetID);
       resultSet.cancelRowUpdates();
    }
 
    @Override
    public void moveToInsertRow() throws SQLException {
-      logger.logf(level, "%s.moveToInsertRow()", resultSetID);
+      logger.trace("{}.moveToInsertRow()", resultSetID);
       resultSet.moveToInsertRow();
    }
 
    @Override
    public void moveToCurrentRow() throws SQLException {
-      logger.logf(level, "%s.moveToCurrentRow()", resultSetID);
+      logger.trace("{}.moveToCurrentRow()", resultSetID);
       resultSet.moveToCurrentRow();
    }
 
    @Override
    public Statement getStatement() throws SQLException {
       Statement x = resultSet.getStatement();
-      logger.logf(level, "%s.getStatement() = %s", resultSetID, x);
+      logger.trace("{}.getStatement() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
       Object x = resultSet.getObject(columnIndex, map);
-      logger.logf(level, "%s.getObject(%s, %s) = %s", resultSetID, columnIndex, map, x);
+      logger.trace("{}.getObject({}, {}) = {}", resultSetID, columnIndex, map, x);
       return x;
    }
 
    @Override
    public Ref getRef(int columnIndex) throws SQLException {
       Ref x = resultSet.getRef(columnIndex);
-      logger.logf(level, "%s.getRef(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getRef({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Blob getBlob(int columnIndex) throws SQLException {
       Blob x = resultSet.getBlob(columnIndex);
-      logger.logf(level, "%s.getBlob(%s) = %s (length: %d)", resultSetID, columnIndex, x, x == null ? null : x.length());
+      logger.trace("{}.getBlob({}) = {} (length: {})", resultSetID, columnIndex, x, x == null ? null : x.length());
       return x;
    }
 
    @Override
    public Clob getClob(int columnIndex) throws SQLException {
       Clob x = resultSet.getClob(columnIndex);
-      logger.logf(level, "%s.getClob(%s) = %s (length: %d)", resultSetID, columnIndex, x, x == null ? null : x.length());
+      logger.trace("{}.getClob({}) = {} (length: {})", resultSetID, columnIndex, x, x == null ? null : x.length());
       return x;
    }
 
    @Override
    public Array getArray(int columnIndex) throws SQLException {
       Array x = resultSet.getArray(columnIndex);
-      logger.logf(level, "%s.getArray(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getArray({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
       Object x = resultSet.getObject(columnLabel, map);
-      logger.logf(level, "%s.getObject(%s, %s) = %s", resultSetID, columnLabel, map, x);
+      logger.trace("{}.getObject({}, {}) = {}", resultSetID, columnLabel, map, x);
       return x;
    }
 
    @Override
    public Ref getRef(String columnLabel) throws SQLException {
       Ref x = resultSet.getRef(columnLabel);
-      logger.logf(level, "%s.getRef(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getRef({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public Blob getBlob(String columnLabel) throws SQLException {
       Blob x = resultSet.getBlob(columnLabel);
-      logger.logf(level, "%s.getBlob(%s) = %s (length: %d)", resultSetID, columnLabel, x, x == null ? null : x.length());
+      logger.trace("{}.getBlob({}) = {} (length: {})", resultSetID, columnLabel, x, x == null ? null : x.length());
       return x;
    }
 
    @Override
    public Clob getClob(String columnLabel) throws SQLException {
       Clob x = resultSet.getClob(columnLabel);
-      logger.logf(level, "%s.getClob(%s) = %s (length: %d)", resultSetID, columnLabel, x, x == null ? null : x.length());
+      logger.trace("{}.getClob({}) = {} (length: {})", resultSetID, columnLabel, x, x == null ? null : x.length());
       return x;
    }
 
    @Override
    public Array getArray(String columnLabel) throws SQLException {
       Array x = resultSet.getArray(columnLabel);
-      logger.logf(level, "%s.getArray(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getArray({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public Date getDate(int columnLabel, Calendar cal) throws SQLException {
       Date x = resultSet.getDate(columnLabel, cal);
-      logger.logf(level, "%s.getDate(%s) = %s", resultSetID, columnLabel, cal, x);
+      logger.trace("{}.getDate({}) = {}", resultSetID, columnLabel, cal, x);
       return x;
    }
 
    @Override
    public Date getDate(String columnLabel, Calendar cal) throws SQLException {
       Date x = resultSet.getDate(columnLabel, cal);
-      logger.logf(level, "%s.getDate(%s) = %s", resultSetID, columnLabel, cal, x);
+      logger.trace("{}.getDate({}) = {}", resultSetID, columnLabel, cal, x);
       return x;
    }
 
    @Override
    public Time getTime(int columnLabel, Calendar cal) throws SQLException {
       Time x = resultSet.getTime(columnLabel, cal);
-      logger.logf(level, "%s.getTime(%s) = %s", resultSetID, columnLabel, cal, x);
+      logger.trace("{}.getTime({}) = {}", resultSetID, columnLabel, cal, x);
       return x;
    }
 
    @Override
    public Time getTime(String columnLabel, Calendar cal) throws SQLException {
       Time x = resultSet.getTime(columnLabel, cal);
-      logger.logf(level, "%s.getTime(%s) = %s", resultSetID, columnLabel, cal, x);
+      logger.trace("{}.getTime({}) = {}", resultSetID, columnLabel, cal, x);
       return x;
    }
 
    @Override
    public Timestamp getTimestamp(int columnLabel, Calendar cal) throws SQLException {
       Timestamp x = resultSet.getTimestamp(columnLabel, cal);
-      logger.logf(level, "%s.getTimestamp(%s) = %s", resultSetID, columnLabel, cal, x);
+      logger.trace("{}.getTimestamp({}) = {}", resultSetID, columnLabel, cal, x);
       return x;
    }
 
    @Override
    public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
       Timestamp x = resultSet.getTimestamp(columnLabel, cal);
-      logger.logf(level, "%s.getTimestamp(%s) = %s", resultSetID, columnLabel, cal, x);
+      logger.trace("{}.getTimestamp({}) = {}", resultSetID, columnLabel, cal, x);
       return x;
    }
 
    @Override
    public URL getURL(int columnLabel) throws SQLException {
       URL x = resultSet.getURL(columnLabel);
-      logger.logf(level, "%s.getURL(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getURL({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public URL getURL(String columnLabel) throws SQLException {
       URL x = resultSet.getURL(columnLabel);
-      logger.logf(level, "%s.getURL(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getURL({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public void updateRef(int columnIndex, Ref x) throws SQLException {
-      logger.logf(level, "%s.updateRef(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateRef({}, {})", resultSetID, columnIndex, x);
       resultSet.updateRef(columnIndex, x);
    }
 
    @Override
    public void updateRef(String columnLabel, Ref x) throws SQLException {
-      logger.logf(level, "%s.updateRef(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateRef({}, {})", resultSetID, columnLabel, x);
       resultSet.updateRef(columnLabel, x);
    }
 
    @Override
    public void updateBlob(int columnIndex, Blob x) throws SQLException {
-      logger.logf(level, "%s.updateBlob(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateBlob({}, {})", resultSetID, columnIndex, x);
       resultSet.updateBlob(columnIndex, x);
    }
 
    @Override
    public void updateBlob(String columnLabel, Blob x) throws SQLException {
-      logger.logf(level, "%s.updateBlob(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateBlob({}, {})", resultSetID, columnLabel, x);
       resultSet.updateBlob(columnLabel, x);
    }
 
    @Override
    public void updateClob(int columnIndex, Clob x) throws SQLException {
-      logger.logf(level, "%s.updateClob(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateClob({}, {})", resultSetID, columnIndex, x);
       resultSet.updateClob(columnIndex, x);
    }
 
    @Override
    public void updateClob(String columnLabel, Clob x) throws SQLException {
-      logger.logf(level, "%s.updateClob(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateClob({}, {})", resultSetID, columnLabel, x);
       resultSet.updateClob(columnLabel, x);
    }
 
    @Override
    public void updateArray(int columnIndex, Array x) throws SQLException {
-      logger.logf(level, "%s.updateArray(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateArray({}, {})", resultSetID, columnIndex, x);
       resultSet.updateArray(columnIndex, x);
    }
 
    @Override
    public void updateArray(String columnLabel, Array x) throws SQLException {
-      logger.logf(level, "%s.updateArray(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateArray({}, {})", resultSetID, columnLabel, x);
       resultSet.updateArray(columnLabel, x);
    }
 
    @Override
    public RowId getRowId(int columnIndex) throws SQLException {
       RowId x = resultSet.getRowId(columnIndex);
-      logger.logf(level, "%s.getRowId(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getRowId({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public RowId getRowId(String columnLabel) throws SQLException {
       RowId x = resultSet.getRowId(columnLabel);
-      logger.logf(level, "%s.getRowId(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getRowId({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public void updateRowId(int columnIndex, RowId x) throws SQLException {
-      logger.logf(level, "%s.updateRowId(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateRowId({}, {})", resultSetID, columnIndex, x);
       resultSet.updateRowId(columnIndex, x);
    }
 
    @Override
    public void updateRowId(String columnLabel, RowId x) throws SQLException {
-      logger.logf(level, "%s.updateRowId(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateRowId({}, {})", resultSetID, columnLabel, x);
       resultSet.updateRowId(columnLabel, x);
    }
 
    @Override
    public int getHoldability() throws SQLException {
       int x = resultSet.getHoldability();
-      logger.logf(level, "%s.getHoldability() = %s", resultSetID, x);
+      logger.trace("{}.getHoldability() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public boolean isClosed() throws SQLException {
       boolean x = resultSet.isClosed();
-      logger.logf(level, "%s.isClosed() = %s", resultSetID, x);
+      logger.trace("{}.isClosed() = {}", resultSetID, x);
       return x;
    }
 
    @Override
    public void updateNString(int columnIndex, String x) throws SQLException {
-      logger.logf(level, "%s.updateNString(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateNString({}, {})", resultSetID, columnIndex, x);
       resultSet.updateNString(columnIndex, x);
    }
 
    @Override
    public void updateNString(String columnLabel, String x) throws SQLException {
-      logger.logf(level, "%s.updateNString(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateNString({}, {})", resultSetID, columnLabel, x);
       resultSet.updateNString(columnLabel, x);
    }
 
    @Override
    public void updateNClob(int columnIndex, NClob x) throws SQLException {
-      logger.logf(level, "%s.updateNClob(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateNClob({}, {})", resultSetID, columnIndex, x);
       resultSet.updateNClob(columnIndex, x);
    }
 
    @Override
    public void updateNClob(String columnLabel, NClob x) throws SQLException {
-      logger.logf(level, "%s.updateNClob(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateNClob({}, {})", resultSetID, columnLabel, x);
       resultSet.updateNClob(columnLabel, x);
    }
 
    @Override
    public NClob getNClob(int columnIndex) throws SQLException {
       NClob x = resultSet.getNClob(columnIndex);
-      logger.logf(level, "%s.getNClob(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getNClob({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public NClob getNClob(String columnLabel) throws SQLException {
       NClob x = resultSet.getNClob(columnLabel);
-      logger.logf(level, "%s.getNClob(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getNClob({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public SQLXML getSQLXML(int columnIndex) throws SQLException {
       SQLXML x = resultSet.getSQLXML(columnIndex);
-      logger.logf(level, "%s.getSQLXML(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getSQLXML({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public SQLXML getSQLXML(String columnLabel) throws SQLException {
       SQLXML x = resultSet.getSQLXML(columnLabel);
-      logger.logf(level, "%s.getSQLXML(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getSQLXML({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public void updateSQLXML(int columnIndex, SQLXML x) throws SQLException {
-      logger.logf(level, "%s.updateSQLXML(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateSQLXML({}, {})", resultSetID, columnIndex, x);
       resultSet.updateSQLXML(columnIndex, x);
    }
 
    @Override
    public void updateSQLXML(String columnLabel, SQLXML x) throws SQLException {
-      logger.logf(level, "%s.updateSQLXML(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateSQLXML({}, {})", resultSetID, columnLabel, x);
       resultSet.updateSQLXML(columnLabel, x);
    }
 
    @Override
    public String getNString(int columnIndex) throws SQLException {
       String x = resultSet.getNString(columnIndex);
-      logger.logf(level, "%s.getNString(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getNString({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public String getNString(String columnLabel) throws SQLException {
       String x = resultSet.getNString(columnLabel);
-      logger.logf(level, "%s.getNString(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getNString({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public Reader getNCharacterStream(int columnIndex) throws SQLException {
       Reader x = resultSet.getNCharacterStream(columnIndex);
-      logger.logf(level, "%s.getNCharacterStream(%s) = %s", resultSetID, columnIndex, x);
+      logger.trace("{}.getNCharacterStream({}) = {}", resultSetID, columnIndex, x);
       return x;
    }
 
    @Override
    public Reader getNCharacterStream(String columnLabel) throws SQLException {
       Reader x = resultSet.getNCharacterStream(columnLabel);
-      logger.logf(level, "%s.getNCharacterStream(%s) = %s", resultSetID, columnLabel, x);
+      logger.trace("{}.getNCharacterStream({}) = {}", resultSetID, columnLabel, x);
       return x;
    }
 
    @Override
    public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
-      logger.logf(level, "%s.updateNCharacterStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateNCharacterStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateNCharacterStream(columnIndex, x, length);
    }
 
    @Override
    public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.updateNCharacterStream(%s, %s, %s)", resultSetID, columnLabel, reader, length);
+      logger.trace("{}.updateNCharacterStream({}, {}, {})", resultSetID, columnLabel, reader, length);
       resultSet.updateNCharacterStream(columnLabel, reader, length);
    }
 
    @Override
    public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
-      logger.logf(level, "%s.updateAsciiStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateAsciiStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateAsciiStream(columnIndex, x, length);
    }
 
    @Override
    public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
-      logger.logf(level, "%s.updateBinaryStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateBinaryStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateBinaryStream(columnIndex, x, length);
    }
 
    @Override
    public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
-      logger.logf(level, "%s.updateCharacterStream(%s, %s, %s)", resultSetID, columnIndex, x, length);
+      logger.trace("{}.updateCharacterStream({}, {}, {})", resultSetID, columnIndex, x, length);
       resultSet.updateCharacterStream(columnIndex, x, length);
    }
 
    @Override
    public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
-      logger.logf(level, "%s.updateAsciiStream(%s, %s, %s)", resultSetID, columnLabel, x, length);
+      logger.trace("{}.updateAsciiStream({}, {}, {})", resultSetID, columnLabel, x, length);
       resultSet.updateAsciiStream(columnLabel, x, length);
    }
 
    @Override
    public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
-      logger.logf(level, "%s.updateBinaryStream(%s, %s, %s)", resultSetID, columnLabel, x, length);
+      logger.trace("{}.updateBinaryStream({}, {}, {})", resultSetID, columnLabel, x, length);
       resultSet.updateBinaryStream(columnLabel, x, length);
    }
 
    @Override
    public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.updateCharacterStream(%s, %s, %s)", resultSetID, columnLabel, reader, length);
+      logger.trace("{}.updateCharacterStream({}, {}, {})", resultSetID, columnLabel, reader, length);
       resultSet.updateCharacterStream(columnLabel, reader);
    }
 
    @Override
    public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
-      logger.logf(level, "%s.updateBlob(%s, %s, %s)", resultSetID, columnIndex, inputStream, length);
+      logger.trace("{}.updateBlob({}, {}, {})", resultSetID, columnIndex, inputStream, length);
       resultSet.updateBlob(columnIndex, inputStream, length);
    }
 
    @Override
    public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
-      logger.logf(level, "%s.updateBlob(%s, %s, %s)", resultSetID, columnLabel, inputStream, length);
+      logger.trace("{}.updateBlob({}, {}, {})", resultSetID, columnLabel, inputStream, length);
       resultSet.updateBlob(columnLabel, inputStream, length);
    }
 
    @Override
    public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.updateClob(%s, %s, %s)", resultSetID, columnIndex, reader, length);
+      logger.trace("{}.updateClob({}, {}, {})", resultSetID, columnIndex, reader, length);
       resultSet.updateClob(columnIndex, reader, length);
    }
 
    @Override
    public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.updateClob(%s, %s, %s)", resultSetID, columnLabel, reader, length);
+      logger.trace("{}.updateClob({}, {}, {})", resultSetID, columnLabel, reader, length);
       resultSet.updateClob(columnLabel, reader, length);
    }
 
    @Override
    public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.updateNClob(%s, %s, %s)", resultSetID, columnIndex, reader, length);
+      logger.trace("{}.updateNClob({}, {}, {})", resultSetID, columnIndex, reader, length);
       resultSet.updateNClob(columnIndex, reader, length);
    }
 
    @Override
    public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
-      logger.logf(level, "%s.updateNClob(%s, %s, %s)", resultSetID, columnLabel, reader, length);
+      logger.trace("{}.updateNClob({}, {}, {})", resultSetID, columnLabel, reader, length);
       resultSet.updateNClob(columnLabel, reader, length);
    }
 
    @Override
    public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
-      logger.logf(level, "%s.updateNCharacterStream(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateNCharacterStream({}, {})", resultSetID, columnIndex, x);
       resultSet.updateNCharacterStream(columnIndex, x);
    }
 
    @Override
    public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
-      logger.logf(level, "%s.updateNCharacterStream(%s, %s)", resultSetID, columnLabel, reader);
+      logger.trace("{}.updateNCharacterStream({}, {})", resultSetID, columnLabel, reader);
       resultSet.updateNCharacterStream(columnLabel, reader);
    }
 
    @Override
    public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
-      logger.logf(level, "%s.updateAsciiStream(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateAsciiStream({}, {})", resultSetID, columnIndex, x);
       resultSet.updateAsciiStream(columnIndex, x);
    }
 
    @Override
    public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
-      logger.logf(level, "%s.updateBinaryStream(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateBinaryStream({}, {})", resultSetID, columnIndex, x);
       resultSet.updateBinaryStream(columnIndex, x);
    }
 
    @Override
    public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
-      logger.logf(level, "%s.updateCharacterStream(%s, %s)", resultSetID, columnIndex, x);
+      logger.trace("{}.updateCharacterStream({}, {})", resultSetID, columnIndex, x);
       resultSet.updateCharacterStream(columnIndex, x);
    }
 
    @Override
    public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
-      logger.logf(level, "%s.updateAsciiStream(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateAsciiStream({}, {})", resultSetID, columnLabel, x);
       resultSet.updateAsciiStream(columnLabel, x);
    }
 
    @Override
    public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
-      logger.logf(level, "%s.updateBinaryStream(%s, %s)", resultSetID, columnLabel, x);
+      logger.trace("{}.updateBinaryStream({}, {})", resultSetID, columnLabel, x);
       resultSet.updateBinaryStream(columnLabel, x);
    }
 
    @Override
    public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
-      logger.logf(level, "%s.updateCharacterStream(%s, %s)", resultSetID, columnLabel, reader);
+      logger.trace("{}.updateCharacterStream({}, {})", resultSetID, columnLabel, reader);
       resultSet.updateCharacterStream(columnLabel, reader);
    }
 
    @Override
    public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
-      logger.logf(level, "%s.updateBlob(%s, %s)", resultSetID, columnIndex, inputStream);
+      logger.trace("{}.updateBlob({}, {})", resultSetID, columnIndex, inputStream);
       resultSet.updateBlob(columnIndex, inputStream);
    }
 
    @Override
    public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
-      logger.logf(level, "%s.updateBlob(%s, %s)", resultSetID, columnLabel, inputStream);
+      logger.trace("{}.updateBlob({}, {})", resultSetID, columnLabel, inputStream);
       resultSet.updateBlob(columnLabel, inputStream);
    }
 
    @Override
    public void updateClob(int columnIndex, Reader reader) throws SQLException {
-      logger.logf(level, "%s.updateClob(%s, %s)", resultSetID, columnIndex, reader);
+      logger.trace("{}.updateClob({}, {})", resultSetID, columnIndex, reader);
       resultSet.updateClob(columnIndex, reader);
    }
 
    @Override
    public void updateClob(String columnLabel, Reader reader) throws SQLException {
-      logger.logf(level, "%s.updateClob(%s, %s)", resultSetID, columnLabel, reader);
+      logger.trace("{}.updateClob({}, {})", resultSetID, columnLabel, reader);
       resultSet.updateClob(columnLabel, reader);
    }
 
    @Override
    public void updateNClob(int columnIndex, Reader reader) throws SQLException {
-      logger.logf(level, "%s.updateNClob(%s, %s)", resultSetID, columnIndex, reader);
+      logger.trace("{}.updateNClob({}, {})", resultSetID, columnIndex, reader);
       resultSet.updateNClob(columnIndex, reader);
    }
 
    @Override
    public void updateNClob(String columnLabel, Reader reader) throws SQLException {
-      logger.logf(level, "%s.updateNClob(%s, %s)", resultSetID, columnLabel, reader);
+      logger.trace("{}.updateNClob({}, {})", resultSetID, columnLabel, reader);
       resultSet.updateNClob(columnLabel, reader);
    }
 
    @Override
    public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
       T x = resultSet.getObject(columnIndex, type);
-      logger.logf(level, "%s.getObject(%s, %s) = %s", resultSetID, columnIndex, type, x);
+      logger.trace("{}.getObject({}, {}) = {}", resultSetID, columnIndex, type, x);
       return x;
    }
 
    @Override
    public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
       T x = resultSet.getObject(columnLabel, type);
-      logger.logf(level, "%s.getObject(%s, %s) = %s", resultSetID, columnLabel, type, x);
+      logger.trace("{}.getObject({}, {}) = {}", resultSetID, columnLabel, type, x);
       return x;
    }
 
    @Override
    public void updateObject(int columnIndex, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s, %s, %s)", resultSetID, columnIndex, x, targetSqlType, scaleOrLength);
+      logger.trace("{}.updateObject({}, {}, {}, {})", resultSetID, columnIndex, x, targetSqlType, scaleOrLength);
       resultSet.updateObject(columnIndex, x, targetSqlType);
    }
 
@@ -1306,33 +1305,33 @@ public class LoggingResultSet implements ResultSet {
                             Object x,
                             SQLType targetSqlType,
                             int scaleOrLength) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s, %s, %s)", resultSetID, columnLabel, x, targetSqlType, scaleOrLength);
+      logger.trace("{}.updateObject({}, {}, {}, {})", resultSetID, columnLabel, x, targetSqlType, scaleOrLength);
       resultSet.updateObject(columnLabel, x, targetSqlType, scaleOrLength);
    }
 
    @Override
    public void updateObject(int columnIndex, Object x, SQLType targetSqlType) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s, %s)", resultSetID, columnIndex, x, targetSqlType);
+      logger.trace("{}.updateObject({}, {}, {})", resultSetID, columnIndex, x, targetSqlType);
       resultSet.updateObject(columnIndex, x, targetSqlType);
    }
 
    @Override
    public void updateObject(String columnLabel, Object x, SQLType targetSqlType) throws SQLException {
-      logger.logf(level, "%s.updateObject(%s, %s, %s)", resultSetID, columnLabel, x, targetSqlType);
+      logger.trace("{}.updateObject({}, {}, {})", resultSetID, columnLabel, x, targetSqlType);
       resultSet.updateObject(columnLabel, x, targetSqlType);
    }
 
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
       T x = resultSet.unwrap(iface);
-      logger.logf(level, "%s.unwrap(%s) = %s", resultSetID, iface, x);
+      logger.trace("{}.unwrap({}) = {}", resultSetID, iface, x);
       return x;
    }
 
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
       boolean x = resultSet.isWrapperFor(iface);
-      logger.logf(level, "%s.isWrapperFor(%s) = %s", resultSetID, iface, x);
+      logger.trace("{}.isWrapperFor({}) = {}", resultSetID, iface, x);
       return x;
    }
 }
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingStatement.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingStatement.java
index 84186f9584..e6686b90f0 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingStatement.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/logging/LoggingStatement.java
@@ -24,7 +24,7 @@ import java.sql.SQLWarning;
 import java.sql.Statement;
 import java.util.Arrays;
 
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
 
 public class LoggingStatement implements Statement {
 
@@ -34,8 +34,6 @@ public class LoggingStatement implements Statement {
 
    protected final Logger logger;
 
-   protected static Logger.Level level = Logger.Level.TRACE;
-
    public LoggingStatement(Statement statement, Logger logger) {
       this.statement = statement;
       this.logger = logger;
@@ -53,348 +51,348 @@ public class LoggingStatement implements Statement {
    @Override
    public ResultSet executeQuery(String sql) throws SQLException {
       LoggingResultSet rs = new LoggingResultSet(statement.executeQuery(sql), logger);
-      logger.logf(level, "%s.executeQuery(%s) = %s", statementID, sql, rs.getResultSetID());
+      logger.trace("{}.executeQuery({}) = {}", statementID, sql, rs.getResultSetID());
       return rs;
    }
 
    @Override
    public int executeUpdate(String sql) throws SQLException {
       int i = statement.executeUpdate(sql);
-      logger.logf(level, "%s.executeUpdate(%s) = %s", statementID, sql, i);
+      logger.trace("{}.executeUpdate({}) = {}", statementID, sql, i);
       return i;
    }
 
    @Override
    public void close() throws SQLException {
-      logger.logf(level, "%s.close()", statementID);
+      logger.trace("{}.close()", statementID);
       statement.close();
    }
 
    @Override
    public int getMaxFieldSize() throws SQLException {
       int i = statement.getMaxFieldSize();
-      logger.logf(level, "%s.getMaxFieldSize() = %s", statementID, i);
+      logger.trace("{}.getMaxFieldSize() = {}", statementID, i);
       return i;
    }
 
    @Override
    public void setMaxFieldSize(int max) throws SQLException {
-      logger.logf(level, "%s.setMaxFieldSize(%d)", statementID, max);
+      logger.trace("{}.setMaxFieldSize({})", statementID, max);
       statement.setMaxFieldSize(max);
    }
 
    @Override
    public int getMaxRows() throws SQLException {
       int i = statement.getMaxRows();
-      logger.logf(level, "%s.getMaxRows() = %s", statementID, i);
+      logger.trace("{}.getMaxRows() = {}", statementID, i);
       return i;
    }
 
    @Override
    public void setMaxRows(int max) throws SQLException {
-      logger.logf(level, "%s.setMaxRows()", statementID);
+      logger.trace("{}.setMaxRows()", statementID);
       statement.setMaxRows(max);
    }
 
    @Override
    public void setEscapeProcessing(boolean enable) throws SQLException {
-      logger.logf(level, "%s.setEscapeProcessing(%s)", statementID, enable);
+      logger.trace("{}.setEscapeProcessing({})", statementID, enable);
       statement.setEscapeProcessing(enable);
    }
 
    @Override
    public int getQueryTimeout() throws SQLException {
       int i = statement.getQueryTimeout();
-      logger.logf(level, "%s.getQueryTimeout() = %s", statementID, i);
+      logger.trace("{}.getQueryTimeout() = {}", statementID, i);
       return i;
    }
 
    @Override
    public void setQueryTimeout(int seconds) throws SQLException {
-      logger.logf(level, "%s.setQueryTimeout(%d)", statementID, seconds);
+      logger.trace("{}.setQueryTimeout({})", statementID, seconds);
       statement.setQueryTimeout(seconds);
    }
 
    @Override
    public void cancel() throws SQLException {
-      logger.logf(level, "%s.cancel()", statementID);
+      logger.trace("{}.cancel()", statementID);
       statement.cancel();
    }
 
    @Override
    public SQLWarning getWarnings() throws SQLException {
-      logger.logf(level, "%s.getWarnings()", statementID);
+      logger.trace("{}.getWarnings()", statementID);
       return statement.getWarnings();
    }
 
    @Override
    public void clearWarnings() throws SQLException {
-      logger.logf(level, "%s.clearWarnings()", statementID);
+      logger.trace("{}.clearWarnings()", statementID);
       statement.clearWarnings();
    }
 
    @Override
    public void setCursorName(String name) throws SQLException {
-      logger.logf(level, "%s.setCursorName(%s)", statementID, name);
+      logger.trace("{}.setCursorName({})", statementID, name);
       statement.setCursorName(name);
    }
 
    @Override
    public boolean execute(String sql) throws SQLException {
       boolean b = statement.execute(sql);
-      logger.logf(level, "%s.execute(%s) = %s", statementID, sql, b);
+      logger.trace("{}.execute({}) = {}", statementID, sql, b);
       return b;
    }
 
    @Override
    public ResultSet getResultSet() throws SQLException {
       LoggingResultSet rs = new LoggingResultSet(statement.getResultSet(), logger);
-      logger.logf(level, "%s.executeQuery() = %s", statementID, rs.getResultSetID());
+      logger.trace("{}.executeQuery() = {}", statementID, rs.getResultSetID());
       return rs;
    }
 
    @Override
    public int getUpdateCount() throws SQLException {
       int i = statement.getUpdateCount();
-      logger.logf(level, "%s.getUpdateCount() = %s", statementID, i);
+      logger.trace("{}.getUpdateCount() = {}", statementID, i);
       return i;
    }
 
    @Override
    public boolean getMoreResults() throws SQLException {
       boolean b = statement.getMoreResults();
-      logger.logf(level, "%s.getMoreResults() = %s", statementID, b);
+      logger.trace("{}.getMoreResults() = {}", statementID, b);
       return b;
    }
 
    @Override
    public void setFetchDirection(int direction) throws SQLException {
-      logger.logf(level, "%s.setFetchDirection()", statementID);
+      logger.trace("{}.setFetchDirection()", statementID);
       statement.setFetchDirection(direction);
    }
 
    @Override
    public int getFetchDirection() throws SQLException {
       int i = statement.getFetchDirection();
-      logger.logf(level, "%s.getFetchDirection() = %s", statementID, i);
+      logger.trace("{}.getFetchDirection() = {}", statementID, i);
       return i;
    }
 
    @Override
    public void setFetchSize(int rows) throws SQLException {
-      logger.logf(level, "%s.setFetchSize(%d)", statementID, rows);
+      logger.trace("{}.setFetchSize({})", statementID, rows);
       statement.setFetchSize(rows);
    }
 
    @Override
    public int getFetchSize() throws SQLException {
       int i = statement.getFetchSize();
-      logger.logf(level, "%s.getFetchSize() = %s", statementID, i);
+      logger.trace("{}.getFetchSize() = {}", statementID, i);
       return i;
    }
 
    @Override
    public int getResultSetConcurrency() throws SQLException {
       int i = statement.getResultSetConcurrency();
-      logger.logf(level, "%s.getResultSetConcurrency() = %s", statementID, i);
+      logger.trace("{}.getResultSetConcurrency() = {}", statementID, i);
       return i;
    }
 
    @Override
    public int getResultSetType() throws SQLException {
       int i = statement.getResultSetType();
-      logger.logf(level, "%s.getResultSetType() = %s", statementID, i);
+      logger.trace("{}.getResultSetType() = {}", statementID, i);
       return i;
    }
 
    @Override
    public void addBatch(String sql) throws SQLException {
-      logger.logf(level, "%s.addBatch(%d, %s)", statementID);
+      logger.trace("{}.addBatch({}, {})", statementID);
       statement.addBatch(sql);
    }
 
    @Override
    public void clearBatch() throws SQLException {
-      logger.logf(level, "%s.clearBatch()", statementID);
+      logger.trace("{}.clearBatch()", statementID);
       statement.clearBatch();
    }
 
    @Override
    public int[] executeBatch() throws SQLException {
       int[] i = statement.executeBatch();
-      logger.logf(level, "%s.executeBatch() = %s", statementID, Arrays.toString(i));
+      logger.trace("{}.executeBatch() = {}", statementID, Arrays.toString(i));
       return i;
    }
 
    @Override
    public Connection getConnection() throws SQLException {
       LoggingConnection connection = new LoggingConnection(statement.getConnection(), logger);
-      logger.logf(level, "%s.getConnection() = %s", statementID, connection.getConnectionID());
+      logger.trace("{}.getConnection() = {}", statementID, connection.getConnectionID());
       return connection;
    }
 
    @Override
    public boolean getMoreResults(int current) throws SQLException {
       boolean b = statement.getMoreResults(current);
-      logger.logf(level, "%s.getMoreResults(%s) = %s", statementID, current, b);
+      logger.trace("{}.getMoreResults({}) = {}", statementID, current, b);
       return b;
    }
 
    @Override
    public ResultSet getGeneratedKeys() throws SQLException {
       LoggingResultSet rs = new LoggingResultSet(statement.getGeneratedKeys(), logger);
-      logger.logf(level, "%s.getGeneratedKeys() = %s", statementID, rs.getResultSetID());
+      logger.trace("{}.getGeneratedKeys() = {}", statementID, rs.getResultSetID());
       return rs;
    }
 
    @Override
    public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
       int i = statement.executeUpdate(sql, autoGeneratedKeys);
-      logger.logf(level, "%s.executeUpdate(%s, %d) = %s", statementID, sql, autoGeneratedKeys, i);
+      logger.trace("{}.executeUpdate({}, {}) = {}", statementID, sql, autoGeneratedKeys, i);
       return i;
    }
 
    @Override
    public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
       int i = statement.executeUpdate(sql, columnIndexes);
-      logger.logf(level, "%s.executeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnIndexes), i);
+      logger.trace("{}.executeUpdate({}, {}) = {}", statementID, sql, Arrays.toString(columnIndexes), i);
       return i;
    }
 
    @Override
    public int executeUpdate(String sql, String[] columnNames) throws SQLException {
       int i = statement.executeUpdate(sql, columnNames);
-      logger.logf(level, "%s.executeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnNames), i);
+      logger.trace("{}.executeUpdate({}, {}) = {}", statementID, sql, Arrays.toString(columnNames), i);
       return i;
    }
 
    @Override
    public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
       boolean b = statement.execute(sql, autoGeneratedKeys);
-      logger.logf(level, "%s.execute(%s, %s) = %s", statementID, sql, autoGeneratedKeys, b);
+      logger.trace("{}.execute({}, {}) = {}", statementID, sql, autoGeneratedKeys, b);
       return b;
    }
 
    @Override
    public boolean execute(String sql, int[] columnIndexes) throws SQLException {
       boolean b = statement.execute(sql, columnIndexes);
-      logger.logf(level, "%s.execute(%s, %s) = %s", statementID, sql, Arrays.toString(columnIndexes), b);
+      logger.trace("{}.execute({}, {}) = {}", statementID, sql, Arrays.toString(columnIndexes), b);
       return b;
    }
 
    @Override
    public boolean execute(String sql, String[] columnNames) throws SQLException {
       boolean b = statement.execute(sql, columnNames);
-      logger.logf(level, "%s.execute(%s, %s) = %s", statementID, sql, Arrays.toString(columnNames), b);
+      logger.trace("{}.execute({}, {}) = {}", statementID, sql, Arrays.toString(columnNames), b);
       return b;
    }
 
    @Override
    public int getResultSetHoldability() throws SQLException {
       int i = statement.getResultSetHoldability();
-      logger.logf(level, "%s.getResultSetHoldability() = %s", statementID, i);
+      logger.trace("{}.getResultSetHoldability() = {}", statementID, i);
       return i;
    }
 
    @Override
    public boolean isClosed() throws SQLException {
       boolean b = statement.isClosed();
-      logger.logf(level, "%s.isClosed() = %s", statementID, b);
+      logger.trace("{}.isClosed() = {}", statementID, b);
       return b;
    }
 
    @Override
    public void setPoolable(boolean poolable) throws SQLException {
-      logger.logf(level, "%s.setPoolable(%s)", statementID, poolable);
+      logger.trace("{}.setPoolable({})", statementID, poolable);
       statement.setPoolable(poolable);
    }
 
    @Override
    public boolean isPoolable() throws SQLException {
       boolean b = statement.isPoolable();
-      logger.logf(level, "%s.isPoolable() = %s", statementID, b);
+      logger.trace("{}.isPoolable() = {}", statementID, b);
       return b;
    }
 
    @Override
    public void closeOnCompletion() throws SQLException {
-      logger.logf(level, "%s.closeOnCompletion()", statementID);
+      logger.trace("{}.closeOnCompletion()", statementID);
       statement.closeOnCompletion();
    }
 
    @Override
    public boolean isCloseOnCompletion() throws SQLException {
       boolean b = statement.isCloseOnCompletion();
-      logger.logf(level, "%s.isCloseOnCompletion() = %s", statementID, b);
+      logger.trace("{}.isCloseOnCompletion() = {}", statementID, b);
       return b;
    }
 
    @Override
    public long getLargeUpdateCount() throws SQLException {
       long x = statement.getLargeUpdateCount();
-      logger.logf(level, "%s.getLargeUpdateCount() = %s", statementID, x);
+      logger.trace("{}.getLargeUpdateCount() = {}", statementID, x);
       return x;
    }
 
    @Override
    public void setLargeMaxRows(long max) throws SQLException {
-      logger.logf(level, "%s.setLargeMaxRows(%d)", statementID, max);
+      logger.trace("{}.setLargeMaxRows({})", statementID, max);
       statement.setLargeMaxRows(max);
    }
 
    @Override
    public long getLargeMaxRows() throws SQLException {
       long x = statement.getLargeMaxRows();
-      logger.logf(level, "%s.getLargeMaxRows() = %s", statementID, x);
+      logger.trace("{}.getLargeMaxRows() = {}", statementID, x);
       return x;
    }
 
    @Override
    public long[] executeLargeBatch() throws SQLException {
       long[] x = statement.executeLargeBatch();
-      logger.logf(level, "%s.executeLargeBatch() = %s", statementID, x);
+      logger.trace("{}.executeLargeBatch() = {}", statementID, x);
       return x;
    }
 
    @Override
    public long executeLargeUpdate(String sql) throws SQLException {
       long x = statement.executeLargeUpdate(sql);
-      logger.logf(level, "%s.executeLargeUpdate(%s) = %s", statementID, sql, x);
+      logger.trace("{}.executeLargeUpdate({}) = {}", statementID, sql, x);
       return x;
    }
 
    @Override
    public long executeLargeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
       long x = statement.executeLargeUpdate(sql, autoGeneratedKeys);
-      logger.logf(level, "%s.executeLargeUpdate() = %s", statementID, sql, autoGeneratedKeys, x);
+      logger.trace("{}.executeLargeUpdate() = {}", statementID, sql, autoGeneratedKeys, x);
       return x;
    }
 
    @Override
    public long executeLargeUpdate(String sql, int[] columnIndexes) throws SQLException {
       long x = statement.executeLargeUpdate(sql, columnIndexes);
-      logger.logf(level, "%s.executeLargeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnIndexes), x);
+      logger.trace("{}.executeLargeUpdate({}, {}) = {}", statementID, sql, Arrays.toString(columnIndexes), x);
       return x;
    }
 
    @Override
    public long executeLargeUpdate(String sql, String[] columnNames) throws SQLException {
       long x = statement.executeLargeUpdate(sql, columnNames);
-      logger.logf(level, "%s.executeLargeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnNames), x);
+      logger.trace("{}.executeLargeUpdate({}, {}) = {}", statementID, sql, Arrays.toString(columnNames), x);
       return x;
    }
 
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
       T x = statement.unwrap(iface);
-      logger.logf(level, "%s.unwrap(%s) = %s", statementID, iface, x);
+      logger.trace("{}.unwrap({}) = {}", statementID, iface, x);
       return x;
    }
 
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
       boolean b = statement.isWrapperFor(iface);
-      logger.logf(level, "%s.isWrapperFor(%s) = %s", statementID, iface, b);
+      logger.trace("{}.isWrapperFor({}) = {}", statementID, iface, b);
       return b;
    }
 }
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java
index 0fb6d953ac..047819b663 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java
@@ -29,7 +29,8 @@ import java.util.stream.Stream;
 
 import org.apache.activemq.artemis.jdbc.store.drivers.JDBCConnectionProvider;
 import org.apache.activemq.artemis.jdbc.store.journal.JDBCJournalImpl;
-import org.jboss.logging.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import static java.lang.String.format;
 
@@ -305,7 +306,7 @@ public class PropertySQLProvider implements SQLProvider {
 
    public static final class Factory implements SQLProvider.Factory {
 
-      private static final Logger logger = Logger.getLogger(JDBCJournalImpl.class);
+      private static final Logger logger = LoggerFactory.getLogger(JDBCJournalImpl.class);
       private static final String SQL_PROPERTIES_FILE = "journal-sql.properties";
       // can be null if no known dialect has been identified
       private SQLDialect dialect;
@@ -393,9 +394,9 @@ public class PropertySQLProvider implements SQLProvider {
                dialect = identifyDialect(metaData.getDriverName());
             }
             if (dialect == null) {
-               logger.warnf("Unable to detect database dialect from connection metadata or JDBC driver name.");
+               logger.warn("Unable to detect database dialect from connection metadata or JDBC driver name.");
             } else {
-               logger.debugf("Detect database dialect as '%s'.", dialect);
+               logger.debug("Detect database dialect as '{}'.", dialect);
             }
          } catch (Exception e) {
             logger.debug("Unable to read JDBC metadata.", e);
diff --git a/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalBundle.java b/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalBundle.java
index baf9057c5c..27d3921de5 100644
--- a/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalBundle.java
+++ b/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalBundle.java
@@ -33,7 +33,7 @@ public interface ActiveMQJournalBundle {
 
    ActiveMQJournalBundle BUNDLE = CodeFactory.getCodeClass(ActiveMQJournalBundle.class);
 
-   @Message(id = 149000, value = "failed to rename file {0} to {1}")
+   @Message(id = 149000, value = "failed to rename file {} to {}")
    ActiveMQIOErrorException ioRenameFileError(String name, String newFileName);
 
    @Message(id = 149001, value = "Journal data belong to a different version")
@@ -48,6 +48,6 @@ public interface ActiveMQJournalBundle {
    @Message(id = 149004, value = "unable to open file")
    String unableToOpenFile();
 
-   @Message(id = 149005, value = "Message of {0} bytes is bigger than the max record size of {1} bytes. You should try to move large application properties to the message body.")
+   @Message(id = 149005, value = "Message of {} bytes is bigger than the max record size of {} bytes. You should try to move large application properties to the message body.")
    ActiveMQIOErrorException recordLargerThanStoreMax(long recordSize, long maxRecordSize);
 }
diff --git a/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalLogger.java b/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalLogger.java
index 721c89c06c..8c578f866b 100644
--- a/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalLogger.java
+++ b/artemis-journal/src/main/java/org/apache/activemq/artemis/journal/ActiveMQJournalLogger.java
@@ -32,16 +32,16 @@ public interface ActiveMQJournalLogger {
     */
    ActiveMQJournalLogger LOGGER = CodeFactory.getCodeClass(ActiveMQJournalLogger.class, ActiveMQJournalLogger.class.getPackage().getName());
 
-   @LogMessage(id = 141000, value = "*** running direct journal blast: {0}", level = LogMessage.Level.INFO)
+   @LogMessage(id = 141000, value = "*** running direct journal blast: {}", level = LogMessage.Level.INFO)
    void runningJournalBlast(Integer numIts);
 
    @LogMessage(id = 141002, value = "starting thread for sync speed test", level = LogMessage.Level.INFO)
    void startingThread();
 
-   @LogMessage(id = 141003, value = "Write rate = {0} bytes / sec or {1} MiB / sec", level = LogMessage.Level.INFO)
+   @LogMessage(id = 141003, value = "Write rate = {} bytes / sec or {} MiB / sec", level = LogMessage.Level.INFO)
    void writeRate(Double rate, Long l);
 
-   @LogMessage(id = 141004, value = "Flush rate = {0} flushes / sec", level = LogMessage.Level.INFO)
+   @LogMessage(id = 141004, value = "Flush rate = {} flushes / sec", level = LogMessage.Level.INFO)
    void flushRate(Double rate);
 
    @LogMessage(id = 141005, value = "Check Data Files:", level = LogMessage.Level.INFO)
@@ -50,7 +50,7 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 141006, value = "Sequence out of order on journal", level = LogMessage.Level.INFO)
    void seqOutOfOrder();
 
-   @LogMessage(id = 141007, value = "Current File on the journal is <= the sequence file.getFileID={0} on the dataFiles" + "\nCurrentfile.getFileId={1} while the file.getFileID()={2}" + "\nIs same = ({3})", level = LogMessage.Level.INFO)
+   @LogMessage(id = 141007, value = "Current File on the journal is <= the sequence file.getFileID={} on the dataFiles" + "\nCurrentfile.getFileId={} while the file.getFileID()={}" + "\nIs same = ({})", level = LogMessage.Level.INFO)
    void currentFile(Long fileID, Long id, Long fileFileID, Boolean b);
 
    @LogMessage(id = 141008, value = "Free File ID out of order", level = LogMessage.Level.INFO)
@@ -59,55 +59,55 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 141009, value = "A Free File is less than the maximum data", level = LogMessage.Level.INFO)
    void fileTooSmall();
 
-   @LogMessage(id = 141010, value = "Initialising JDBC data source {0} with properties {1}", level = LogMessage.Level.INFO)
+   @LogMessage(id = 141010, value = "Initialising JDBC data source {} with properties {}", level = LogMessage.Level.INFO)
    void initializingJdbcDataSource(String dataSourceClassName, String dataSourceProperties);
 
    @LogMessage(id = 142000, value = "You have a native library with a different version than expected", level = LogMessage.Level.WARN)
    void incompatibleNativeLibrary();
 
-   @LogMessage(id = 142001, value = "Could not get lock after 60 seconds on closing Asynchronous File: {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142001, value = "Could not get lock after 60 seconds on closing Asynchronous File: {}", level = LogMessage.Level.WARN)
    void couldNotGetLock(String fileName);
 
-   @LogMessage(id = 142002, value = "Asynchronous File: {0} being finalized with opened state", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142002, value = "Asynchronous File: {} being finalized with opened state", level = LogMessage.Level.WARN)
    void fileFinalizedWhileOpen(String fileName);
 
-   @LogMessage(id = 142003, value = "AIO Callback Error: {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142003, value = "AIO Callback Error: {}", level = LogMessage.Level.WARN)
    void callbackError(String error);
 
-   @LogMessage(id = 142004, value = "Inconsistency during compacting: CommitRecord ID = {0} for an already committed transaction during compacting", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142004, value = "Inconsistency during compacting: CommitRecord ID = {} for an already committed transaction during compacting", level = LogMessage.Level.WARN)
    void inconsistencyDuringCompacting(Long transactionID);
 
-   @LogMessage(id = 142005, value = "Inconsistency during compacting: Delete record being read on an existent record (id={0})", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142005, value = "Inconsistency during compacting: Delete record being read on an existent record (id={})", level = LogMessage.Level.WARN)
    void inconsistencyDuringCompactingDelete(Long recordID);
 
-   @LogMessage(id = 142006, value = "Could not find add Record information for record {0} during compacting", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142006, value = "Could not find add Record information for record {} during compacting", level = LogMessage.Level.WARN)
    void compactingWithNoAddRecord(Long id);
 
-   @LogMessage(id = 142007, value = "Can not find record {0} during compact replay", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142007, value = "Can not find record {} during compact replay", level = LogMessage.Level.WARN)
    void noRecordDuringCompactReplay(Long id);
 
-   @LogMessage(id = 142008, value = "Could not remove file {0} from the list of data files", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142008, value = "Could not remove file {} from the list of data files", level = LogMessage.Level.WARN)
    void couldNotRemoveFile(JournalFile file);
 
-   @LogMessage(id = 142009, value = "*******************************************************************************************************************************\nThe File Storage Attic is full, as the file {0}  does not have the configured size, and the file will be removed\n*******************************************************************************************************************************", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142009, value = "*******************************************************************************************************************************\nThe File Storage Attic is full, as the file {}  does not have the configured size, and the file will be removed\n*******************************************************************************************************************************", level = LogMessage.Level.WARN)
    void deletingFile(JournalFile file);
 
-   @LogMessage(id = 142010, value = "Failed to add file to opened files queue: {0}. This should NOT happen!", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142010, value = "Failed to add file to opened files queue: {}. This should NOT happen!", level = LogMessage.Level.WARN)
    void failedToAddFile(JournalFile nextOpenedFile);
 
-   @LogMessage(id = 142011, value = "Error on reading compacting for {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142011, value = "Error on reading compacting for {}", level = LogMessage.Level.WARN)
    void compactReadError(JournalFile file);
 
-   @LogMessage(id = 142012, value = "Couldn''t find tx={0} to merge after compacting", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142012, value = "Couldn''t find tx={} to merge after compacting", level = LogMessage.Level.WARN)
    void compactMergeError(Long id);
 
-   @LogMessage(id = 142013, value = "Prepared transaction {0} was not considered completed, it will be ignored", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142013, value = "Prepared transaction {} was not considered completed, it will be ignored", level = LogMessage.Level.WARN)
    void preparedTXIncomplete(Long id);
 
-   @LogMessage(id = 142014, value = "Transaction {0} is missing elements so the transaction is being ignored", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142014, value = "Transaction {} is missing elements so the transaction is being ignored", level = LogMessage.Level.WARN)
    void txMissingElements(Long id);
 
-   @LogMessage(id = 142015, value = "Uncommitted transaction with id {0} found and discarded", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142015, value = "Uncommitted transaction with id {} found and discarded", level = LogMessage.Level.WARN)
    void uncomittedTxFound(Long id);
 
    @LogMessage(id = 142016, value = "Could not stop compactor executor after 120 seconds", level = LogMessage.Level.WARN)
@@ -119,19 +119,19 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 142018, value = "Temporary files were left unattended after a crash on journal directory, deleting invalid files now", level = LogMessage.Level.WARN)
    void tempFilesLeftOpen();
 
-   @LogMessage(id = 142019, value = "Deleting orphaned file {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142019, value = "Deleting orphaned file {}", level = LogMessage.Level.WARN)
    void deletingOrphanedFile(String fileToDelete);
 
-   @LogMessage(id = 142020, value = "Could not get lock after 60 seconds on closing Asynchronous File: {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142020, value = "Could not get lock after 60 seconds on closing Asynchronous File: {}", level = LogMessage.Level.WARN)
    void errorClosingFile(String fileToDelete);
 
-   @LogMessage(id = 142021, value = "Error on IO callback, {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142021, value = "Error on IO callback, {}", level = LogMessage.Level.WARN)
    void errorOnIOCallback(String errorMessage);
 
    @LogMessage(id = 142022, value = "Timed out on AIO poller shutdown", level = LogMessage.Level.WARN)
    void timeoutOnPollerShutdown(Exception e);
 
-   @LogMessage(id = 142023, value = "Executor on file {0} couldn''t complete its tasks in 60 seconds.", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142023, value = "Executor on file {} couldn''t complete its tasks in 60 seconds.", level = LogMessage.Level.WARN)
    void couldNotCompleteTask(Exception e, String name);
 
    @LogMessage(id = 142024, value = "Error completing callback", level = LogMessage.Level.WARN)
@@ -143,7 +143,7 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 142026, value = "Timed out on AIO writer shutdown", level = LogMessage.Level.WARN)
    void timeoutOnWriterShutdown(Throwable e);
 
-   @LogMessage(id = 142027, value = "Error on writing data! {0} code - {1}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142027, value = "Error on writing data! {} code - {}", level = LogMessage.Level.WARN)
    void errorWritingData(Throwable e, String errorMessage, Integer errorCode);
 
    @LogMessage(id = 142028, value = "Error replaying pending commands after compacting", level = LogMessage.Level.WARN)
@@ -155,13 +155,13 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 142030, value = "Could not open a file in 60 Seconds", level = LogMessage.Level.WARN)
    void errorOpeningFile(Throwable e);
 
-   @LogMessage(id = 142031, value = "Error retrieving ID part of the file name {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142031, value = "Error retrieving ID part of the file name {}", level = LogMessage.Level.WARN)
    void errorRetrievingID(Throwable e, String fileName);
 
    @LogMessage(id = 142032, value = "Error reading journal file", level = LogMessage.Level.WARN)
    void errorReadingFile(Throwable e);
 
-   @LogMessage(id = 142033, value = "Error reinitializing file {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 142033, value = "Error reinitializing file {}", level = LogMessage.Level.WARN)
    void errorReinitializingFile(Throwable e, JournalFile file);
 
    @LogMessage(id = 142034, value = "Exception on submitting write", level = LogMessage.Level.WARN)
@@ -170,7 +170,7 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 142035, value = "Could not stop journal append executor after 60 seconds", level = LogMessage.Level.WARN)
    void couldNotStopJournalAppendExecutor();
 
-   @LogMessage(id = 144000, value = "Failed to delete file {0}", level = LogMessage.Level.ERROR)
+   @LogMessage(id = 144000, value = "Failed to delete file {}", level = LogMessage.Level.ERROR)
    void errorDeletingFile(Object e);
 
    @LogMessage(id = 144001, value = "Error starting poller", level = LogMessage.Level.ERROR)
@@ -188,19 +188,19 @@ public interface ActiveMQJournalLogger {
    @LogMessage(id = 144005, value = "Failed to performance blast", level = LogMessage.Level.ERROR)
    void failedToPerfBlast(Throwable e);
 
-   @LogMessage(id = 144006, value = "IOError code {0}, {1}", level = LogMessage.Level.ERROR)
+   @LogMessage(id = 144006, value = "IOError code {}, {}", level = LogMessage.Level.ERROR)
    void ioError(int errorCode, String errorMessage);
 
-   @LogMessage(id = 144007, value = "Ignoring journal file {0}: file is shorter then minimum header size. This file is being removed.", level = LogMessage.Level.WARN)
+   @LogMessage(id = 144007, value = "Ignoring journal file {}: file is shorter then minimum header size. This file is being removed.", level = LogMessage.Level.WARN)
    void ignoringShortFile(String fileName);
 
-   @LogMessage(id = 144008, value = "*******************************************************************************************************************************\nFile {0}: was moved under attic, please review it and remove it.\n*******************************************************************************************************************************", level = LogMessage.Level.WARN)
+   @LogMessage(id = 144008, value = "*******************************************************************************************************************************\nFile {}: was moved under attic, please review it and remove it.\n*******************************************************************************************************************************", level = LogMessage.Level.WARN)
    void movingFileToAttic(String fileName);
 
-   @LogMessage(id = 144009, value = "Could not get a file in {0} seconds, System will retry the open but you may see increased latency in your system", level = LogMessage.Level.WARN)
+   @LogMessage(id = 144009, value = "Could not get a file in {} seconds, System will retry the open but you may see increased latency in your system", level = LogMessage.Level.WARN)
    void cantOpenFileTimeout(long timeout);
 
-   @LogMessage(id = 144010, value = "Critical IO Exception happened: {0}", level = LogMessage.Level.WARN)
+   @LogMessage(id = 144010, value = "Critical IO Exception happened: {}", level = LogMessage.Level.WARN)
    void criticalIO(String message, Exception error);
 
 }
diff --git a/artemis-log-processor/src/main/java/org/apache/activemq/artemis/logprocessor/CodeFactory.java b/artemis-log-processor/src/main/java/org/apache/activemq/artemis/logprocessor/CodeFactory.java
index 5169d1deb4..6f126c461d 100644
--- a/artemis-log-processor/src/main/java/org/apache/activemq/artemis/logprocessor/CodeFactory.java
+++ b/artemis-log-processor/src/main/java/org/apache/activemq/artemis/logprocessor/CodeFactory.java
@@ -34,8 +34,8 @@ public class CodeFactory {
          public T run() {
             try {
                String className = type.getName() + "_impl";
-               System.out.println("Loading [" + className + "]");
-               Class messageClass = Class.forName(className, true, type.getClassLoader()).asSubclass(type);
+               System.out.println("Loading [" + className + "]"); //TODO: remove or make Logger
+               Class<?> messageClass = Class.forName(className, true, type.getClassLoader()).asSubclass(type);
 
                Field field = messageClass.getField("INSTANCE");
 


[activemq-artemis] 02/02: some TODOs around logger names etc

Posted by ro...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

robbie pushed a commit to branch new-logging
in repository https://gitbox.apache.org/repos/asf/activemq-artemis.git

commit d19b372d30cf15b271eee69cc250bb364407b205
Author: Robbie Gemmell <ro...@apache.org>
AuthorDate: Wed May 11 13:24:46 2022 +0100

    some TODOs around logger names etc
---
 .../activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java   | 2 ++
 .../activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java   | 4 +++-
 .../apache/activemq/artemis/jdbc/store/journal/JDBCJournalRecord.java | 2 ++
 .../apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java   | 2 +-
 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java
index c85eec48e0..98c32e9d44 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/drivers/JDBCConnectionProvider.java
@@ -80,6 +80,8 @@ public class JDBCConnectionProvider {
             } catch (SQLException e) {
                supportNetworkTimeout = false;
                logger.warn(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e).toString());
+               // TODO: looks like this used the "ActiveMQJournalLogger.class.getPackage().getName()" logger before, not this class own named logger.
+               //       Should it still, or swap to the local one? If former should it have a code?
                ActiveMQJournalLogger.LOGGER.warn("Unable to set a network timeout on the JDBC connection: won't retry again in the future");
             } catch (Throwable throwable) {
                supportNetworkTimeout = false;
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java
index cba736b05c..b876877af9 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactory.java
@@ -39,7 +39,7 @@ import org.slf4j.LoggerFactory;
 
 public class JDBCSequentialFileFactory implements SequentialFileFactory, ActiveMQComponent {
 
-   private static final Logger logger = LoggerFactory.getLogger(JDBCSequentialFile.class);
+   private static final Logger logger = LoggerFactory.getLogger(JDBCSequentialFile.class);//TODO: wrong logger name?
 
    private boolean started;
 
@@ -105,6 +105,8 @@ public class JDBCSequentialFileFactory implements SequentialFileFactory, ActiveM
       try {
          dbDriver.stop();
       } catch (SQLException e) {
+         // TODO: looks like this used the "ActiveMQJournalLogger.class.getPackage().getName()" logger before, not this class own named logger.
+         //       Should it still, or swap to the local one? If former should it have a code?
          ActiveMQJournalLogger.LOGGER.error("Error stopping file factory, unable to close db connection");
       }
       started = false;
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalRecord.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalRecord.java
index 1ae8d1d91b..68a203d463 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalRecord.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/journal/JDBCJournalRecord.java
@@ -137,6 +137,8 @@ class JDBCJournalRecord {
          record.read(recordBytes);
          txData.read(txDataBytes);
       } catch (IOException e) {
+          // TODO: looks like this used the "ActiveMQJournalLogger.class.getPackage().getName()" logger before, not this class own named logger.
+          //       Should it still, or swap to the local one? If former should it have a code?
          ActiveMQJournalLogger.LOGGER.error("Error occurred whilst reading Journal Record", e);
          throw e;
       }
diff --git a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java
index 047819b663..32c1f4262f 100644
--- a/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java
+++ b/artemis-jdbc-store/src/main/java/org/apache/activemq/artemis/jdbc/store/sql/PropertySQLProvider.java
@@ -306,7 +306,7 @@ public class PropertySQLProvider implements SQLProvider {
 
    public static final class Factory implements SQLProvider.Factory {
 
-      private static final Logger logger = LoggerFactory.getLogger(JDBCJournalImpl.class);
+      private static final Logger logger = LoggerFactory.getLogger(JDBCJournalImpl.class); //TODO: wrong logger name or deliberate?
       private static final String SQL_PROPERTIES_FILE = "journal-sql.properties";
       // can be null if no known dialect has been identified
       private SQLDialect dialect;