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:53 UTC
[activemq-artemis] 01/02: update more of artemis-jdbc-store, but not all in order to note specific issues
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");