This is an automated email from the ASF dual-hosted git repository.
sk0x50 pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new e32fd8d092 IGNITE 19148 Switch tests from using JUL to log4j2 (#2429)
e32fd8d092 is described below
commit e32fd8d092ed1a3074013dcd2cb64f2b1b50ab18
Author: Slava Koptilin <slava.kopti...@gmail.com>
AuthorDate: Mon Aug 21 13:48:41 2023 +0300
IGNITE 19148 Switch tests from using JUL to log4j2 (#2429)
---
build.gradle | 1 -
buildscripts/java-integration-test.gradle | 5 +
buildscripts/java-junit5.gradle | 5 +
buildscripts/java-test-fixtures.gradle | 5 +
config/java.util.logging.properties | 57 ----
gradle/libs.versions.toml | 7 +
modules/catalog/build.gradle | 1 -
.../cli/commands/ItClusterCommandTest.java | 44 +--
modules/client-handler/build.gradle | 1 -
modules/cluster-management/build.gradle | 1 -
modules/configuration-presentation/build.gradle | 1 -
.../testframework/BaseIgniteAbstractTest.java | 14 -
.../internal/testframework/jul/NoOpHandler.java | 36 --
.../testframework/log4j2/LogInspector.java | 364 +++++++++++++++++++++
.../resources/java.util.logging.properties | 57 ----
.../src/testFixtures/resources/log4j2-test.xml | 58 ++++
modules/index/build.gradle | 1 -
modules/network/build.gradle | 3 +-
.../scalecube/ItScaleCubeNetworkMessagingTest.java | 36 +-
modules/raft/build.gradle | 1 -
modules/rest/build.gradle | 1 -
modules/runner/build.gradle | 1 -
.../raftsnapshot/ItTableRaftSnapshotsTest.java | 69 ++--
.../apache/ignite/internal/start/ItStartTest.java | 42 ++-
modules/sql-engine/build.gradle | 1 -
modules/table/build.gradle | 1 -
26 files changed, 529 insertions(+), 284 deletions(-)
diff --git a/build.gradle b/build.gradle
index 974560658a..bd9d33f11f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -67,7 +67,6 @@ allprojects {
"--add-opens=java.base/jdk.internal.misc=ALL-UNNAMED",
"--add-opens=java.base/sun.security.x509=ALL-UNNAMED",
"-Dio.netty.tryReflectionSetAccessible=true",
-
"-Djava.util.logging.config.file=${project.rootDir}/config/java.util.logging.properties",
"-XX:+HeapDumpOnOutOfMemoryError"]
systemProperty 'jraft.available_processors', 1
diff --git a/buildscripts/java-integration-test.gradle
b/buildscripts/java-integration-test.gradle
index 173598386d..b683fdb3db 100644
--- a/buildscripts/java-integration-test.gradle
+++ b/buildscripts/java-integration-test.gradle
@@ -35,6 +35,11 @@ testing {
implementation libs.hamcrest.core
implementation libs.hamcrest.optional
implementation libs.hamcrest.path
+
+ implementation libs.jansi.core
+ implementation libs.log4j.api
+ implementation libs.log4j.core
+ implementation libs.log4j.bridge
}
sources {
diff --git a/buildscripts/java-junit5.gradle b/buildscripts/java-junit5.gradle
index f233c06084..f29fc1d6fa 100644
--- a/buildscripts/java-junit5.gradle
+++ b/buildscripts/java-junit5.gradle
@@ -33,4 +33,9 @@ dependencies {
testImplementation libs.junit5.impl
testImplementation libs.junit5.api
testImplementation libs.junit5.params
+
+ testImplementation libs.jansi.core
+ testImplementation libs.log4j.api
+ testImplementation libs.log4j.core
+ testImplementation libs.log4j.bridge
}
diff --git a/buildscripts/java-test-fixtures.gradle
b/buildscripts/java-test-fixtures.gradle
index 49ec0f1f60..17feb22e60 100644
--- a/buildscripts/java-test-fixtures.gradle
+++ b/buildscripts/java-test-fixtures.gradle
@@ -20,6 +20,11 @@ apply plugin: 'java-test-fixtures'
dependencies {
testFixturesImplementation libs.junit5.api
testFixturesImplementation libs.junit5.impl
+
+ testFixturesImplementation libs.jansi.core
+ testFixturesImplementation libs.log4j.api
+ testFixturesImplementation libs.log4j.core
+ testFixturesImplementation libs.log4j.bridge
}
pmdTestFixtures {
diff --git a/config/java.util.logging.properties
b/config/java.util.logging.properties
deleted file mode 100644
index 9a4ef63f5f..0000000000
--- a/config/java.util.logging.properties
+++ /dev/null
@@ -1,57 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-#########################################################################
-# Default java.util.logging configuration for Ignite.
-#
-# To use another config file use `java.util.logging.config.file` system
-# property. For example `java -Djava.util.logging.config.file=myfile`
-#########################################################################
-
-#
-# Comma-separated list of logging "handlers". Note that some of them may be
-# reconfigured (or even removed) at runtime according to system properties.
-#
-# By default all messages will be passed to console and file.
-#
-handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler
-
-#
-# Default global logging level.
-# This specifies which kinds of events are logged across all loggers.
-# For any given category this global level can be overriden by a category
-# specific level.
-# Note that handlers also have a separate level setting to limit messages
-# printed through it.
-#
-.level=INFO
-
-# Console handler logs all messages with importance level `INFO` and above
-# into standard error stream (`System.err`).
-#
-java.util.logging.ConsoleHandler.formatter =
org.apache.ignite.lang.JavaLoggerFormatter
-java.util.logging.ConsoleHandler.level = INFO
-
-#
-# File handler logs all messages into files with pattern `ignite-%g.log`
-# under `build` directory.
-#
-java.util.logging.FileHandler.formatter =
org.apache.ignite.lang.JavaLoggerFormatter
-java.util.logging.FileHandler.pattern = build/ignite-%g.log
-java.util.logging.FileHandler.level = INFO
-java.util.logging.FileHandler.limit = 10485760
-java.util.logging.FileHandler.count = 10
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 089e0e4176..0484a1ee7c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -44,6 +44,7 @@ micronautReactor="2.5.0"
mockito = "5.4.0"
picocli = "4.7.0"
slf4j = "2.0.7"
+log4j = "2.19.0"
spoon = "8.4.0-beta-18"
swagger = "2.2.8"
swaggerLegacy = "1.6.4"
@@ -153,7 +154,13 @@ jackson-databind = { module =
"com.fasterxml.jackson.core:jackson-databind", ver
jackson-annotations = { module =
"com.fasterxml.jackson.core:jackson-annotations", version.ref = "jackson" }
typesafe-config = { module = "com.typesafe:config", version.ref = "typesafe" }
+
slf4j-jdk14 = { module = "org.slf4j:slf4j-jdk14", version.ref = "slf4j" }
+slf4j-log4j = { module = "org.apache.logging.log4j:log4j-slf4j2-impl",
version.ref = "log4j" }
+
+log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref =
"log4j" }
+log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref =
"log4j" }
+log4j-bridge = { module = "org.apache.logging.log4j:log4j-jpl", version.ref =
"log4j" }
gson-core = { module = "com.google.code.gson:gson", version.ref = "gson" }
gson-fire = { module = "io.gsonfire:gson-fire", version.ref = "gsonFire" }
diff --git a/modules/catalog/build.gradle b/modules/catalog/build.gradle
index 43b2579ee7..ab97262744 100644
--- a/modules/catalog/build.gradle
+++ b/modules/catalog/build.gradle
@@ -44,7 +44,6 @@ dependencies {
testImplementation libs.mockito.junit
testImplementation libs.mockito.core
testImplementation libs.hamcrest.core
- testImplementation libs.slf4j.jdk14
testFixturesImplementation libs.jetbrains.annotations
testFixturesImplementation libs.mockito.core
diff --git
a/modules/cli/src/integrationTest/java/org/apache/ignite/internal/cli/commands/ItClusterCommandTest.java
b/modules/cli/src/integrationTest/java/org/apache/ignite/internal/cli/commands/ItClusterCommandTest.java
index 24a5c5f998..ad34c566ba 100644
---
a/modules/cli/src/integrationTest/java/org/apache/ignite/internal/cli/commands/ItClusterCommandTest.java
+++
b/modules/cli/src/integrationTest/java/org/apache/ignite/internal/cli/commands/ItClusterCommandTest.java
@@ -34,15 +34,12 @@ import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.concurrent.CountDownLatch;
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
-import java.util.logging.Logger;
import org.apache.ignite.IgnitionManager;
import org.apache.ignite.internal.cli.AbstractCliTest;
import org.apache.ignite.internal.testframework.TestIgnitionManager;
import org.apache.ignite.internal.testframework.WorkDirectory;
import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
-import org.apache.ignite.internal.testframework.jul.NoOpHandler;
+import org.apache.ignite.internal.testframework.log4j2.LogInspector;
import org.hamcrest.Matcher;
import org.hamcrest.Matchers;
import org.junit.jupiter.api.AfterEach;
@@ -70,42 +67,35 @@ class ItClusterCommandTest extends AbstractCliTest {
private static final String NL = System.lineSeparator();
- private static final Logger topologyLogger =
Logger.getLogger("org.apache.ignite.network.scalecube.ScaleCubeTopologyService");
-
@BeforeEach
void setup(@WorkDirectory Path workDir, TestInfo testInfo) throws
Exception {
CountDownLatch allNodesAreInPhysicalTopology = new CountDownLatch(1);
- Handler physicalTopologyWaiter =
physicalTopologyWaiter(allNodesAreInPhysicalTopology);
- topologyLogger.addHandler(physicalTopologyWaiter);
+ LogInspector topologyLogInspector = new LogInspector(
+ "org.apache.ignite.network.scalecube.ScaleCubeTopologyService",
+ evt -> {
+ String msg = evt.getMessage().getFormattedMessage();
+ if (msg.startsWith(TOPOLOGY_SNAPSHOT_LOG_RECORD_PREFIX)) {
+ var ids =
msg.substring(TOPOLOGY_SNAPSHOT_LOG_RECORD_PREFIX.length(),
msg.lastIndexOf(']'))
+ .split(",");
+
+ return ids.length == NODES.size();
+ }
+ return false;
+ },
+ allNodesAreInPhysicalTopology::countDown);
+
+ topologyLogInspector.start();
try {
startClusterWithoutInit(workDir, testInfo);
waitTillAllNodesJoinPhysicalTopology(allNodesAreInPhysicalTopology);
} finally {
- topologyLogger.removeHandler(physicalTopologyWaiter);
+ topologyLogInspector.stop();
}
}
- private Handler physicalTopologyWaiter(CountDownLatch
physicalTopologyIsFull) {
- return new NoOpHandler() {
- @Override
- public void publish(LogRecord record) {
- var msg = record.getMessage();
-
- if (msg.startsWith(TOPOLOGY_SNAPSHOT_LOG_RECORD_PREFIX)) {
- var ids =
msg.substring(TOPOLOGY_SNAPSHOT_LOG_RECORD_PREFIX.length(),
msg.lastIndexOf(']'))
- .split(",");
-
- if (ids.length == NODES.size()) {
- physicalTopologyIsFull.countDown();
- }
- }
- }
- };
- }
-
private void startClusterWithoutInit(Path workDir, TestInfo testInfo) {
NODES.parallelStream().forEach(node -> startNodeWithoutInit(node,
workDir, testInfo));
}
diff --git a/modules/client-handler/build.gradle
b/modules/client-handler/build.gradle
index 17907c6f81..cc1332637e 100644
--- a/modules/client-handler/build.gradle
+++ b/modules/client-handler/build.gradle
@@ -38,7 +38,6 @@ dependencies {
implementation project(':ignite-transactions')
implementation libs.jetbrains.annotations
implementation libs.fastutil.core
- implementation libs.slf4j.jdk14
implementation libs.netty.common
implementation libs.netty.buffer
implementation libs.netty.codec
diff --git a/modules/cluster-management/build.gradle
b/modules/cluster-management/build.gradle
index af1e25bf62..071979b27a 100644
--- a/modules/cluster-management/build.gradle
+++ b/modules/cluster-management/build.gradle
@@ -50,7 +50,6 @@ dependencies {
testImplementation project(':ignite-network')
testImplementation libs.hamcrest.core
testImplementation libs.mockito.junit
- testImplementation libs.slf4j.jdk14
testFixturesImplementation project(':ignite-core')
testFixturesImplementation project(':ignite-raft')
diff --git a/modules/configuration-presentation/build.gradle
b/modules/configuration-presentation/build.gradle
index e0b90d4a33..9efd2495b2 100644
--- a/modules/configuration-presentation/build.gradle
+++ b/modules/configuration-presentation/build.gradle
@@ -34,7 +34,6 @@ dependencies {
testImplementation project(':ignite-configuration')
testImplementation testFixtures(project(':ignite-core'))
testImplementation testFixtures(project(':ignite-configuration'))
- testImplementation libs.slf4j.jdk14
testImplementation libs.micronaut.junit5
testImplementation libs.micronaut.http.client
testImplementation libs.mockito.core
diff --git
a/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/BaseIgniteAbstractTest.java
b/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/BaseIgniteAbstractTest.java
index fe2aaa1091..b650ee641f 100644
---
a/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/BaseIgniteAbstractTest.java
+++
b/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/BaseIgniteAbstractTest.java
@@ -22,11 +22,8 @@ import static
org.apache.ignite.lang.IgniteSystemProperties.IGNITE_SENSITIVE_DAT
import static org.apache.ignite.lang.IgniteSystemProperties.getString;
import static org.mockito.Mockito.framework;
-import java.io.IOException;
-import java.io.InputStream;
import java.lang.reflect.Method;
import java.nio.file.Path;
-import java.util.logging.LogManager;
import org.apache.ignite.internal.logger.IgniteLogger;
import org.apache.ignite.internal.logger.Loggers;
import org.apache.ignite.internal.tostring.S;
@@ -47,18 +44,7 @@ public abstract class BaseIgniteAbstractTest {
/** Test start time in milliseconds. */
private long testStartMs;
- //
- // IDEA test runner didn't apply provided from Gradle scripts
-Djava.util.logging.config.file
- // So, we need to apply logging properties manually to {@link LogManager}.
- //
static {
- try (InputStream is = BaseIgniteAbstractTest.class.getClassLoader()
- .getResourceAsStream("java.util.logging.properties")) {
- LogManager.getLogManager().readConfiguration(is);
- } catch (IOException e) {
- throw new IllegalStateException("Logger properties not found.");
- }
-
/* Init test env. */
S.setSensitiveDataLoggingPolicySupplier(() ->
SensitiveDataLoggingPolicy.valueOf(getString(IGNITE_SENSITIVE_DATA_LOGGING,
"hash").toUpperCase()));
diff --git
a/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/jul/NoOpHandler.java
b/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/jul/NoOpHandler.java
deleted file mode 100644
index 91077381d9..0000000000
---
a/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/jul/NoOpHandler.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.testframework.jul;
-
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
-
-/**
- * Adapter for {@link Handler} with empty implementations of all methods but
{@link Handler#publish(LogRecord)}.
- */
-public abstract class NoOpHandler extends Handler {
- @Override
- public void flush() {
- // no-op
- }
-
- @Override
- public void close() throws SecurityException {
- // no-op
- }
-}
diff --git
a/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/log4j2/LogInspector.java
b/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/log4j2/LogInspector.java
new file mode 100755
index 0000000000..fae0b21f81
--- /dev/null
+++
b/modules/core/src/testFixtures/java/org/apache/ignite/internal/testframework/log4j2/LogInspector.java
@@ -0,0 +1,364 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.testframework.log4j2;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Predicate;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Appender;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.LoggerConfig;
+import org.apache.logging.log4j.core.config.Property;
+
+/**
+ * This class is used to check log events/messages.
+ * <p>
+ * When it is needed to check log events/messages, the following steps should
be performed:
+ * </p>
+ * <pre><code>
+ * // Create a new instance of LogInspector for the given logger name and
specified predicate.
+ * LogInspector logInspector = new LogInspector(
+ * CustomClass.class.getName(),
+ * evt -> evt.getMessage().getFormattedMessage().matches(pattern)
&& evt.getLevel() == Level.ERROR);
+ *
+ * logInspector.start();
+ * try {
+ * // do something
+ * } finally {
+ * logInspector.stop();
+ * }
+ *
+ * assertThat(logInspector.isMatched(), is(true));
+ * </code></pre>
+ * <p>
+ * When it is needed to check log events/messages and perform some action,
just add a predicate and an action:
+ * </p>
+ * <pre><code>
+ * AtomicInteger messageCounter = new AtomicInteger();
+ * LogInspector checker = new LogInspector(
+ * CustomClass.class.getName(),
+ * evt -> evt.getMessage().getFormattedMessage().matches(pattern)
&& evt.getLevel() == Level.ERROR,
+ * // This action will be executed when the predicate is matched.
+ * () -> {
+ * messageCounter.incrementAndGet();
+ * });
+ *
+ * logInspector.start();
+ * try {
+ * // do something
+ * } finally {
+ * logInspector.stop();
+ * }
+ *
+ * assertThat(messageCounter.get(), is(42));
+ * </code></pre>
+ * <p>
+ * It is possible to add a new pair of predicate and action using {@link
#addHandler(Predicate, Runnable)},
+ * {@link #addHandler(Handler)} methods at any time.
+ * </p>
+ */
+public class LogInspector {
+ /** Logger name. */
+ private final String loggerName;
+
+ /** List of handlers. */
+ private final List<Handler> handlers = new ArrayList<>(1);
+
+ /** Lock that is used to synchronize the collection of handlers. */
+ private final ReadWriteLock lock = new ReentrantReadWriteLock();
+
+ /** Test log appender that is used to check log events/messages. */
+ private final TestLogAppender appender;
+
+ /** Logger configuration. */
+ private Configuration config;
+
+ /**
+ * Creates a new instance of {@link LogInspector} for the given {@code
loggerName}.
+ *
+ * @return New instance of {@link LogInspector}.
+ **/
+ public static LogInspector create(String loggerName) {
+ return create(loggerName, false);
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector} for the given {@code
loggerName}.
+ *
+ * @param started Whether the checker should be started.
+ * @return New instance of {@link LogInspector}.
+ **/
+ public static LogInspector create(String loggerName, boolean started) {
+ LogInspector checker = new LogInspector(loggerName);
+
+ if (started) {
+ checker.start();
+ }
+
+ return checker;
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector} for the given {@code
clazz}.
+ *
+ * @return New instance of {@link LogInspector}.
+ **/
+ public static LogInspector create(Class<?> clazz) {
+ return create(clazz, false);
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector} for the given {@code
clazz}.
+ *
+ * @param started Whether the checker should be started.
+ * @return New instance of {@link LogInspector}.
+ **/
+ public static LogInspector create(Class<?> clazz, boolean started) {
+ return create(clazz.getName(), started);
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector}.
+ *
+ * @param loggerName Logger name.
+ */
+ public LogInspector(String loggerName) {
+ Objects.requireNonNull(loggerName);
+
+ this.loggerName = loggerName;
+ this.appender = new TestLogAppender(loggerName);
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector} with the given {@code
predicate}.
+ * In order to check that the required log event was logged, use {@link
#isMatched()} method.
+ *
+ * @param loggerName Logger name.
+ * @param predicate Predicate to check log messages.
+ */
+ public LogInspector(String loggerName, Predicate<LogEvent> predicate) {
+ this(loggerName, predicate, () -> {});
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector} with the given {@code
predicate} and {@code action}.
+ *
+ * @param loggerName Logger name.
+ * @param predicate Predicate to check log messages.
+ * @param action Action to be executed when the {@code predicate} is
matched.
+ */
+ public LogInspector(String loggerName, Predicate<LogEvent> predicate,
Runnable action) {
+ this(loggerName, new Handler(predicate, action));
+ }
+
+ /**
+ * Creates a new instance of {@link LogInspector} with the given list of
{@code handlers}.
+ *
+ * @param loggerName Logger name.
+ * @param handlers List of handlers to be added.
+ */
+ public LogInspector(String loggerName, Handler... handlers) {
+ this(loggerName);
+
+ lock.writeLock().lock();
+ try {
+ Collections.addAll(this.handlers, handlers);
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+
+ /**
+ * Adds a new handler with the given {@code predicate} and {@code action}.
+ *
+ * @param predicate Predicate to check log messages.
+ * @param action Action to be executed when the {@code predicate} is
matched.
+ * @return New instance of {@link Handler}.
+ */
+ public Handler addHandler(Predicate<LogEvent> predicate, Runnable action) {
+ Handler handler = new Handler(predicate, action);
+
+ addHandler(handler);
+
+ return handler;
+ }
+
+ /**
+ * Adds a new handler with the given {@code predicate} and {@code action}.
+ *
+ * @param handler Handler to be added.
+ */
+ public void addHandler(Handler handler) {
+ lock.writeLock().lock();
+ try {
+ handlers.add(handler);
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+
+ /**
+ * Removes the given {@code handler}.
+ *
+ * @param handler Handler to be removed.
+ */
+ public void removeHandler(Handler handler) {
+ Objects.requireNonNull(handler);
+
+ lock.writeLock().lock();
+ try {
+ handlers.remove(handler);
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+
+ /**
+ * Checks if any of the predicates is matched.
+ *
+ * @return {@code true} if one of the predicates is matched, {@code false}
otherwise.
+ */
+ public boolean isMatched() {
+ lock.readLock().lock();
+
+ try {
+ return handlers.stream().anyMatch(handler ->
handler.isMatched.get());
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ /**
+ * Starts the test log checker.
+ *
+ * @throws IllegalStateException If the checker is already started.
+ */
+ public void start() {
+ if (config != null) {
+ throw new IllegalStateException("TestLogChecker is already
started.");
+ }
+
+ Logger logger = (Logger) LogManager.getLogger(appender.getName());
+
+ config = logger.getContext().getConfiguration();
+
+ appender.start();
+
+ addAppender(appender, config);
+ }
+
+ /**
+ * Stops the test log checker.
+ *
+ * @throws IllegalStateException If the checker is not started.
+ */
+ public void stop() {
+ if (config == null) {
+ throw new IllegalStateException("TestLogChecker is not started.");
+ }
+
+ appender.stop();
+
+ removeAppender(appender, config);
+ }
+
+ private static synchronized void addAppender(Appender appender,
Configuration config) {
+ for (LoggerConfig loggerConfig : config.getLoggers().values()) {
+ loggerConfig.addAppender(appender, null, null);
+ }
+ config.getRootLogger().addAppender(appender, null, null);
+ }
+
+ private static synchronized void removeAppender(Appender appender,
Configuration config) {
+ for (LoggerConfig loggerConfig : config.getLoggers().values()) {
+ loggerConfig.removeAppender(appender.getName());
+ }
+ config.getRootLogger().removeAppender(appender.getName());
+ }
+
+ /**
+ * Log event handler.
+ */
+ public static class Handler {
+ /** Predicate that is used to check log messages. */
+ private final Predicate<LogEvent> predicate;
+
+ /** Action to be executed when the {@code predicate} is matched. */
+ private final Runnable action;
+
+ /** Flag indicating whether the predicate is matched. */
+ private final AtomicBoolean isMatched = new AtomicBoolean();
+
+ /**
+ * Creates a new instance of {@link Handler}.
+ *
+ * @param predicate Predicate to check log messages.
+ * @param action Action to be executed when the {@code predicate} is
matched.
+ */
+ public Handler(Predicate<LogEvent> predicate, Runnable action) {
+ Objects.requireNonNull(predicate);
+ Objects.requireNonNull(action);
+
+ this.predicate = predicate;
+ this.action = action;
+ }
+
+ /**
+ * Checks if the predicate is matched.
+ *
+ * @return {@code true} if the predicate is matched, {@code false}
otherwise.
+ */
+ public boolean isMatched() {
+ return isMatched.get();
+ }
+ }
+
+ private class TestLogAppender extends AbstractAppender {
+ public TestLogAppender(String name) {
+ super(name, null, null, true, Property.EMPTY_ARRAY);
+ }
+
+ @Override
+ public void append(LogEvent event) {
+ if (!loggerName.equals(event.getLoggerName())) {
+ return;
+ }
+
+ lock.readLock().lock();
+ try {
+ handlers.forEach(handler -> {
+ if (handler.predicate.test(event)) {
+ handler.isMatched.set(true);
+ handler.action.run();
+ }
+ });
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+ }
+}
diff --git
a/modules/core/src/testFixtures/resources/java.util.logging.properties
b/modules/core/src/testFixtures/resources/java.util.logging.properties
deleted file mode 100644
index 9a4ef63f5f..0000000000
--- a/modules/core/src/testFixtures/resources/java.util.logging.properties
+++ /dev/null
@@ -1,57 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-#########################################################################
-# Default java.util.logging configuration for Ignite.
-#
-# To use another config file use `java.util.logging.config.file` system
-# property. For example `java -Djava.util.logging.config.file=myfile`
-#########################################################################
-
-#
-# Comma-separated list of logging "handlers". Note that some of them may be
-# reconfigured (or even removed) at runtime according to system properties.
-#
-# By default all messages will be passed to console and file.
-#
-handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler
-
-#
-# Default global logging level.
-# This specifies which kinds of events are logged across all loggers.
-# For any given category this global level can be overriden by a category
-# specific level.
-# Note that handlers also have a separate level setting to limit messages
-# printed through it.
-#
-.level=INFO
-
-# Console handler logs all messages with importance level `INFO` and above
-# into standard error stream (`System.err`).
-#
-java.util.logging.ConsoleHandler.formatter =
org.apache.ignite.lang.JavaLoggerFormatter
-java.util.logging.ConsoleHandler.level = INFO
-
-#
-# File handler logs all messages into files with pattern `ignite-%g.log`
-# under `build` directory.
-#
-java.util.logging.FileHandler.formatter =
org.apache.ignite.lang.JavaLoggerFormatter
-java.util.logging.FileHandler.pattern = build/ignite-%g.log
-java.util.logging.FileHandler.level = INFO
-java.util.logging.FileHandler.limit = 10485760
-java.util.logging.FileHandler.count = 10
diff --git a/modules/core/src/testFixtures/resources/log4j2-test.xml
b/modules/core/src/testFixtures/resources/log4j2-test.xml
new file mode 100755
index 0000000000..3e07e837ed
--- /dev/null
+++ b/modules/core/src/testFixtures/resources/log4j2-test.xml
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<Configuration>
+ <Properties>
+ <!-- Set the `IGNITE_CI` environment variable to completely disable colors
in the console output. -->
+ <Property name="disableAnsi">${env:IGNITE_CI:-false}</Property>
+ </Properties>
+
+ <Appenders>
+ <Console name="CONSOLE" target="SYSTEM_OUT">
+ <PatternLayout
+ pattern="[%d{ISO8601}]%highlight{[%-5p]}{INFO=green, DEBUG=green bold,
TRACE=blue}%style{[%t]}{magenta}%style{[%c{1}]}{cyan}%notEmpty{[%markerSimpleName]}
%m%n"
+ disableAnsi="${disableAnsi}"/>
+ <LevelRangeFilter minLevel="INFO" maxLevel="DEBUG"/>
+ </Console>
+
+ <Console name="CONSOLE_ERR" target="SYSTEM_ERR">
+ <PatternLayout
+ pattern="%highlight{[%d{ISO8601}][%-5p][%t][%c{1}] %m%n}{FATAL=red
blink, ERROR=default, WARN=yellow bold}"
+ disableAnsi="${disableAnsi}"/>
+ </Console>
+
+ <RollingFile name="FILE"
+ append="true"
+ fileName="build/ignite.log"
+ filePattern="build/ignite.log.%i">
+ <PatternLayout
pattern="[%d{ISO8601}][%-5p][%t][%c{1}]%notEmpty{[%markerSimpleName]} %m%n"/>
+ <Policies>
+ <SizeBasedTriggeringPolicy size="10 MB"/>
+ </Policies>
+ <DefaultRolloverStrategy max="10"/>
+ </RollingFile>
+ </Appenders>
+
+ <Loggers>
+ <Root level="INFO">
+ <AppenderRef ref="CONSOLE" level="DEBUG"/>
+ <AppenderRef ref="CONSOLE_ERR" level="WARN"/>
+ <AppenderRef ref="FILE" level="DEBUG"/>
+ </Root>
+ </Loggers>
+</Configuration>
diff --git a/modules/index/build.gradle b/modules/index/build.gradle
index 455be1b734..d7bf5fb91c 100644
--- a/modules/index/build.gradle
+++ b/modules/index/build.gradle
@@ -37,7 +37,6 @@ dependencies {
testImplementation libs.mockito.core
testImplementation libs.mockito.junit
testImplementation libs.hamcrest.core
- testImplementation libs.slf4j.jdk14
}
description = 'ignite-index'
diff --git a/modules/network/build.gradle b/modules/network/build.gradle
index fb33f0694c..9944c87007 100644
--- a/modules/network/build.gradle
+++ b/modules/network/build.gradle
@@ -60,10 +60,10 @@ dependencies {
testImplementation libs.mockito.core
testImplementation libs.mockito.junit
testImplementation libs.javapoet
- testImplementation libs.slf4j.jdk14
testImplementation libs.bytebuddy
testImplementation libs.compileTesting
testImplementation libs.awaitility
+ testImplementation libs.slf4j.log4j
testFixturesAnnotationProcessor
project(":ignite-network-annotation-processor")
testFixturesImplementation project(':ignite-configuration')
@@ -73,6 +73,7 @@ dependencies {
testFixturesImplementation libs.fastutil.core
testFixturesImplementation libs.scalecube.cluster
testFixturesImplementation libs.jetbrains.annotations
+ testFixturesImplementation libs.slf4j.log4j
integrationTestAnnotationProcessor
project(":ignite-network-annotation-processor")
diff --git
a/modules/network/src/integrationTest/java/org/apache/ignite/network/scalecube/ItScaleCubeNetworkMessagingTest.java
b/modules/network/src/integrationTest/java/org/apache/ignite/network/scalecube/ItScaleCubeNetworkMessagingTest.java
index 782725c95a..9feea21095 100644
---
a/modules/network/src/integrationTest/java/org/apache/ignite/network/scalecube/ItScaleCubeNetworkMessagingTest.java
+++
b/modules/network/src/integrationTest/java/org/apache/ignite/network/scalecube/ItScaleCubeNetworkMessagingTest.java
@@ -34,6 +34,7 @@ import io.scalecube.cluster.ClusterImpl;
import io.scalecube.cluster.transport.api.Transport;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
@@ -44,9 +45,7 @@ import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
-import java.util.logging.Logger;
+import java.util.function.Predicate;
import org.apache.ignite.internal.network.NetworkMessageTypes;
import org.apache.ignite.internal.network.NetworkMessagesFactory;
import org.apache.ignite.internal.network.messages.TestMessage;
@@ -56,7 +55,7 @@ import
org.apache.ignite.internal.network.netty.ConnectionManager;
import
org.apache.ignite.internal.network.recovery.RecoveryClientHandshakeManager;
import
org.apache.ignite.internal.network.recovery.RecoveryServerHandshakeManager;
import
org.apache.ignite.internal.network.recovery.message.HandshakeFinishMessage;
-import org.apache.ignite.internal.testframework.jul.NoOpHandler;
+import org.apache.ignite.internal.testframework.log4j2.LogInspector;
import org.apache.ignite.lang.IgniteBiTuple;
import org.apache.ignite.lang.NodeStoppingException;
import org.apache.ignite.network.ClusterNode;
@@ -68,6 +67,7 @@ import org.apache.ignite.network.NodeFinder;
import org.apache.ignite.network.StaticNodeFinder;
import org.apache.ignite.network.TopologyEventHandler;
import org.apache.ignite.utils.ClusterServiceTestUtils;
+import org.apache.logging.log4j.core.LogEvent;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
@@ -87,10 +87,15 @@ class ItScaleCubeNetworkMessagingTest {
/** Message factory. */
private final TestMessagesFactory messageFactory = new
TestMessagesFactory();
+ /** List of test log inspectors. */
+ private final List<LogInspector> logInspectors = new ArrayList<>();
+
/** Tear down method. */
@AfterEach
public void tearDown() {
testCluster.shutdown();
+ logInspectors.forEach(LogInspector::stop);
+ logInspectors.clear();
}
/**
@@ -412,20 +417,19 @@ class ItScaleCubeNetworkMessagingTest {
}
});
- Handler rejectedHandshakeHandler = new NoOpHandler() {
- @Override
- public void publish(LogRecord record) {
- if (record.getMessage().startsWith("Handshake rejected by ")) {
- ready.countDown();
- }
- }
- };
+ Predicate<LogEvent> matcher = evt ->
evt.getMessage().getFormattedMessage().startsWith("Handshake rejected by ");
+
+ logInspectors.add(new LogInspector(
+ RecoveryClientHandshakeManager.class.getName(),
+ matcher,
+ ready::countDown));
- Logger clientHandshakeManagerLogger =
Logger.getLogger(RecoveryClientHandshakeManager.class.getName());
- clientHandshakeManagerLogger.addHandler(rejectedHandshakeHandler);
+ logInspectors.add(new LogInspector(
+ RecoveryServerHandshakeManager.class.getName(),
+ matcher,
+ ready::countDown));
- Logger serverHandshakeManagerLogger =
Logger.getLogger(RecoveryServerHandshakeManager.class.getName());
- serverHandshakeManagerLogger.addHandler(rejectedHandshakeHandler);
+ logInspectors.forEach(LogInspector::start);
testCluster.members.stream()
.filter(service -> !outcastName.equals(service.nodeName()))
diff --git a/modules/raft/build.gradle b/modules/raft/build.gradle
index f5479e6a1e..f37d6dd86d 100644
--- a/modules/raft/build.gradle
+++ b/modules/raft/build.gradle
@@ -53,7 +53,6 @@ dependencies {
testImplementation libs.netty.common
testImplementation libs.hamcrest.core
testImplementation libs.jmh.core
- testImplementation libs.slf4j.jdk14
testFixturesAnnotationProcessor
project(":ignite-network-annotation-processor")
testFixturesImplementation project(':ignite-core')
diff --git a/modules/rest/build.gradle b/modules/rest/build.gradle
index 1e07759058..bf5e7e0dc3 100644
--- a/modules/rest/build.gradle
+++ b/modules/rest/build.gradle
@@ -57,7 +57,6 @@ dependencies {
testImplementation project(':ignite-configuration')
testImplementation testFixtures(project(':ignite-core'))
testImplementation testFixtures(project(':ignite-configuration'))
- testImplementation libs.slf4j.jdk14
testImplementation libs.micronaut.junit5
testImplementation libs.micronaut.http.client
testImplementation libs.mockito.core
diff --git a/modules/runner/build.gradle b/modules/runner/build.gradle
index e793f5cf0b..1d11625efe 100644
--- a/modules/runner/build.gradle
+++ b/modules/runner/build.gradle
@@ -83,7 +83,6 @@ dependencies {
implementation libs.micronaut.runtime
implementation libs.micronaut.picocli
implementation libs.picocli.core
- implementation libs.slf4j.jdk14
implementation libs.typesafe.config
implementation libs.auto.service.annotations
implementation libs.disruptor
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/raftsnapshot/ItTableRaftSnapshotsTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/raftsnapshot/ItTableRaftSnapshotsTest.java
index cfc9bc7c9d..c0be52dfa6 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/raftsnapshot/ItTableRaftSnapshotsTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/raftsnapshot/ItTableRaftSnapshotsTest.java
@@ -46,9 +46,6 @@ import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
-import java.util.logging.Logger;
import java.util.stream.IntStream;
import org.apache.calcite.sql.validate.SqlValidatorException;
import org.apache.ignite.internal.Cluster;
@@ -66,7 +63,8 @@ import
org.apache.ignite.internal.storage.rocksdb.RocksDbStorageEngine;
import
org.apache.ignite.internal.table.distributed.raft.snapshot.message.SnapshotMetaResponse;
import org.apache.ignite.internal.testframework.IgniteTestUtils;
import org.apache.ignite.internal.testframework.WorkDirectory;
-import org.apache.ignite.internal.testframework.jul.NoOpHandler;
+import org.apache.ignite.internal.testframework.log4j2.LogInspector;
+import org.apache.ignite.internal.testframework.log4j2.LogInspector.Handler;
import org.apache.ignite.lang.ErrorGroups.Sql;
import org.apache.ignite.lang.IgniteBiTuple;
import org.apache.ignite.lang.IgniteException;
@@ -130,7 +128,7 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
private Cluster cluster;
- private Logger replicatorLogger;
+ private LogInspector replicatorLogInspector;
private @Nullable Handler replicaLoggerHandler;
@@ -138,16 +136,18 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
void createCluster(TestInfo testInfo) {
cluster = new Cluster(testInfo, workDir, NODE_BOOTSTRAP_CFG);
- replicatorLogger = Logger.getLogger(Replicator.class.getName());
+ replicatorLogInspector = LogInspector.create(Replicator.class, true);
}
@AfterEach
@Timeout(60)
void shutdownCluster() {
if (replicaLoggerHandler != null) {
- replicatorLogger.removeHandler(replicaLoggerHandler);
+ replicatorLogInspector.removeHandler(replicaLoggerHandler);
}
+ replicatorLogInspector.stop();
+
cluster.shutdown();
}
@@ -464,23 +464,18 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
private void reanimateNodeAndWaitForSnapshotInstalled(int nodeIndex)
throws InterruptedException {
CountDownLatch snapshotInstalledLatch = new CountDownLatch(1);
- var handler = new NoOpHandler() {
- @Override
- public void publish(LogRecord record) {
- if (record.getMessage().matches("Node .+ received
InstallSnapshotResponse from .+_" + nodeIndex + " .+ success=true")) {
- snapshotInstalledLatch.countDown();
- }
- }
- };
-
- replicatorLogger.addHandler(handler);
+ Handler handler = replicatorLogInspector.addHandler(
+ evt -> evt.getMessage().getFormattedMessage().matches(
+ "Node .+ received InstallSnapshotResponse from .+_" +
nodeIndex + " .+ success=true"),
+ () -> snapshotInstalledLatch.countDown()
+ );
try {
reanimateNode(nodeIndex);
assertTrue(snapshotInstalledLatch.await(60, TimeUnit.SECONDS),
"Did not install a snapshot in time");
} finally {
- replicatorLogger.removeHandler(handler);
+ replicatorLogInspector.removeHandler(handler);
}
}
@@ -734,18 +729,15 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
void
snapshotInstallTimeoutDoesNotBreakSubsequentInstallsWhenSecondAttemptIsIdenticalToFirst()
throws Exception {
AtomicBoolean snapshotInstallFailedDueToIdenticalRetry = new
AtomicBoolean(false);
- Logger snapshotExecutorLogger =
Logger.getLogger(SnapshotExecutorImpl.class.getName());
+ LogInspector snapshotExecutorLogInspector =
LogInspector.create(SnapshotExecutorImpl.class);
- var snapshotInstallFailedDueToIdenticalRetryHandler = new
NoOpHandler() {
- @Override
- public void publish(LogRecord record) {
- if (record.getMessage().contains("Register DownloadingSnapshot
failed: interrupted by retry installing request")) {
- snapshotInstallFailedDueToIdenticalRetry.set(true);
- }
- }
- };
+ Handler snapshotInstallFailedDueToIdenticalRetryHandler =
+ snapshotExecutorLogInspector.addHandler(
+ evt -> evt.getMessage().getFormattedMessage().contains(
+ "Register DownloadingSnapshot failed:
interrupted by retry installing request"),
+ () ->
snapshotInstallFailedDueToIdenticalRetry.set(true));
-
snapshotExecutorLogger.addHandler(snapshotInstallFailedDueToIdenticalRetryHandler);
+ snapshotExecutorLogInspector.start();
try {
prepareClusterForInstallingSnapshotToNode2(DEFAULT_STORAGE_ENGINE,
theCluster -> {
@@ -764,7 +756,8 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
reanimateNode2AndWaitForSnapshotInstalled();
} finally {
-
snapshotExecutorLogger.removeHandler(snapshotInstallFailedDueToIdenticalRetryHandler);
+
snapshotExecutorLogInspector.removeHandler(snapshotInstallFailedDueToIdenticalRetryHandler);
+ snapshotExecutorLogInspector.stop();
}
}
@@ -805,7 +798,7 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
}
/**
- * Adds a listener for the {@link #replicatorLogger} to hear the success
of the snapshot installation.
+ * Adds a listener for the {@link #replicatorLogInspector} to hear the
success of the snapshot installation.
*/
private void listenForSnapshotInstalledSuccessFromLogger(
int nodeIndexFrom,
@@ -814,19 +807,9 @@ class ItTableRaftSnapshotsTest extends
IgniteIntegrationTest {
) {
String regexp = "Node .+" + nodeIndexFrom + " received
InstallSnapshotResponse from .+_" + nodeIndexTo + " .+ success=true";
- replicaLoggerHandler = new NoOpHandler() {
- @Override
- public void publish(LogRecord record) {
- if (record.getMessage().matches(regexp)) {
- snapshotInstallSuccessfullyFuture.complete(null);
-
- replicatorLogger.removeHandler(this);
- replicaLoggerHandler = null;
- }
- }
- };
-
- replicatorLogger.addHandler(replicaLoggerHandler);
+ replicaLoggerHandler = replicatorLogInspector.addHandler(
+ evt -> evt.getMessage().getFormattedMessage().matches(regexp),
+ () -> snapshotInstallSuccessfullyFuture.complete(null));
}
/**
diff --git
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/start/ItStartTest.java
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/start/ItStartTest.java
index f1fbef40e7..52f363a48b 100644
---
a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/start/ItStartTest.java
+++
b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/start/ItStartTest.java
@@ -26,19 +26,19 @@ import static org.hamcrest.Matchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertAll;
import java.nio.file.Path;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
-import java.util.logging.Handler;
-import java.util.logging.LogRecord;
-import java.util.logging.Logger;
import org.apache.ignite.internal.Cluster;
import org.apache.ignite.internal.IgniteIntegrationTest;
import org.apache.ignite.internal.app.IgniteImpl;
import org.apache.ignite.internal.index.IndexManager;
import org.apache.ignite.internal.testframework.IgniteTestUtils;
import org.apache.ignite.internal.testframework.WorkDirectory;
-import org.apache.ignite.internal.testframework.jul.NoOpHandler;
+import org.apache.ignite.internal.testframework.log4j2.LogInspector;
+import org.apache.ignite.internal.testframework.log4j2.LogInspector.Handler;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -79,14 +79,17 @@ class ItStartTest extends IgniteIntegrationTest {
new Expectation("startComplete",
"org.apache.ignite.internal.app.LifecycleManager", "Start complete")
);
+ Map<String, LogInspector> inspectors = new HashMap<>();
+
List<LoggingProbe> probes = expectations.stream()
- .map(ItStartTest::installProbe)
+ .map(expectation -> installProbe(expectation, inspectors))
.collect(toList());
try {
cluster.startAndInit(1);
} finally {
probes.forEach(LoggingProbe::cleanup);
+ inspectors.values().forEach(LogInspector::stop);
}
assertAll(
@@ -104,23 +107,18 @@ class ItStartTest extends IgniteIntegrationTest {
return "%" + IgniteTestUtils.testNodeName(testInfo, 0) + "%start-";
}
- private static LoggingProbe installProbe(Expectation expectation) {
- Logger logger = Logger.getLogger(expectation.loggerClassName);
+ private static LoggingProbe installProbe(Expectation expectation,
Map<String, LogInspector> inspectors) {
+ LogInspector inspector = inspectors.computeIfAbsent(
+ expectation.loggerClassName,
+ loggerClassName -> LogInspector.create(loggerClassName, true));
AtomicReference<String> threadNameRef = new AtomicReference<>();
- var handler = new NoOpHandler() {
- @Override
- public void publish(LogRecord record) {
- if (record.getMessage().matches(expectation.messageRegexp)) {
- threadNameRef.set(Thread.currentThread().getName());
- }
- }
- };
-
- logger.addHandler(handler);
+ Handler handler = inspector.addHandler(
+ evt ->
evt.getMessage().getFormattedMessage().matches(expectation.messageRegexp),
+ () -> threadNameRef.set(Thread.currentThread().getName()));
- return new LoggingProbe(expectation, logger, handler, threadNameRef);
+ return new LoggingProbe(expectation, inspector, handler,
threadNameRef);
}
@Test
@@ -170,19 +168,19 @@ class ItStartTest extends IgniteIntegrationTest {
private static class LoggingProbe {
private final Expectation expectation;
- private final Logger logger;
+ private final LogInspector inspector;
private final Handler handler;
private final AtomicReference<String> threadNameRef;
- private LoggingProbe(Expectation expectation, Logger logger, Handler
handler, AtomicReference<String> threadNameRef) {
+ private LoggingProbe(Expectation expectation, LogInspector inspector,
Handler handler, AtomicReference<String> threadNameRef) {
this.expectation = expectation;
- this.logger = logger;
+ this.inspector = inspector;
this.handler = handler;
this.threadNameRef = threadNameRef;
}
void cleanup() {
- logger.removeHandler(handler);
+ inspector.removeHandler(handler);
}
}
}
diff --git a/modules/sql-engine/build.gradle b/modules/sql-engine/build.gradle
index 20da54336e..c7e33c78cf 100644
--- a/modules/sql-engine/build.gradle
+++ b/modules/sql-engine/build.gradle
@@ -86,7 +86,6 @@ dependencies {
testImplementation libs.mockito.junit
testImplementation libs.mockito.core
testImplementation libs.hamcrest.core
- testImplementation libs.slf4j.jdk14
testImplementation libs.archunit.core
testImplementation libs.archunit.junit5
diff --git a/modules/table/build.gradle b/modules/table/build.gradle
index f9f41e1a48..c57b42a7fd 100644
--- a/modules/table/build.gradle
+++ b/modules/table/build.gradle
@@ -68,7 +68,6 @@ dependencies {
testImplementation libs.hamcrest.core
testImplementation libs.hamcrest.optional
testImplementation libs.junit.pioneer
- testImplementation libs.slf4j.jdk14
testImplementation libs.jmh.core
testImplementation libs.javax.annotations
