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