diff --git a/checkstyle/checkstyle-suppressions.xml b/checkstyle/checkstyle-suppressions.xml
index 3e8a741c92542..9a40f8d4b725a 100644
--- a/checkstyle/checkstyle-suppressions.xml
+++ b/checkstyle/checkstyle-suppressions.xml
@@ -39,9 +39,6 @@
     <suppress checks="(?&lt;!Missing)JavadocMethod"
               files="[\\/]tests[\\/]"/>
 
-    <suppress checks="(?&lt;!Missing)JavadocMethod"
-              files="[\\/]ml[\\/]"/>
-
     <suppress checks="(?&lt;!Missing)JavadocMethod"
               files="[\\/]yardstick[\\/]"/>
 
@@ -54,6 +51,9 @@
     <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
               files="[\\/]internal[\\/]thread[\\/]"/>
 
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="org[\\/]apache[\\/]ignite[\\/]thread[\\/]"/>
+
     <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
               files="[\\/]internal[\\/]jdbc[\\/]thin[\\/]"/>
 
@@ -64,11 +64,14 @@
               files="[\\/]io[\\/]opencensus[\\/]"/>
 
     <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
-              files="[\\/]test[\\/]|[\\/]tests[\\/]"/>
+              files="[\\/]test[\\/]|[\\/]tests[\\/]||[\\/]testframework[\\/]"/>
 
     <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
               files="DumpReader\.java|CacheLoadOnlyStoreAdapter\.java"/>
 
+    <suppress checks="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule"
+              files="CdcCommandLineStartup\.java"/>
+
     <suppress-xpath checks="AnnotationOnSameLine"
                     query="//ANNOTATION[.//IDENT[not(@text='Override')]]"/>
 </suppressions>
diff --git a/checkstyle/checkstyle.xml b/checkstyle/checkstyle.xml
index 6775611e16cdb..d1423237dadf6 100644
--- a/checkstyle/checkstyle.xml
+++ b/checkstyle/checkstyle.xml
@@ -224,6 +224,11 @@
             <property name="factoryMethods" value="allOf, anyOf, supplyAsync, runAsync, completedFuture"/>
             <property name="substitutionClassName" value="org.apache.ignite.internal.thread.context.concurrent.IgniteCompletableFuture"/>
         </module>
+
+        <module name="org.apache.ignite.tools.checkstyle.ClassUsageRestrictionRule">
+            <property name="className" value="java.lang.Thread"/>
+            <property name="substitutionClassName" value="org.apache.ignite.thread.IgniteThread"/>
+        </module>
     </module>
 
     <!--
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/util/CommonUtils.java b/modules/commons/src/main/java/org/apache/ignite/internal/util/CommonUtils.java
index ef31895a40cad..46ebe48608ce0 100644
--- a/modules/commons/src/main/java/org/apache/ignite/internal/util/CommonUtils.java
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/util/CommonUtils.java
@@ -81,6 +81,7 @@
 import org.apache.ignite.lang.IgniteFutureCancelledException;
 import org.apache.ignite.lang.IgniteFutureTimeoutException;
 import org.apache.ignite.lang.IgnitePredicate;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.Nullable;
 
 import static java.util.Objects.isNull;
@@ -541,27 +542,27 @@ public static long currentTimeMillis() {
 
     /**
      * Starts clock timer if grid is first.
+     *
+     * @param igniteInstanceName Ignite instance name.
      */
-    public static void onGridStart() {
+    @SuppressWarnings({"BusyWait"})
+    public static void onGridStart(String igniteInstanceName) {
         synchronized (mux) {
             if (gridCnt == 0) {
                 assert timer == null;
 
-                timer = new Thread(new Runnable() {
-                    @SuppressWarnings({"BusyWait"})
-                    @Override public void run() {
-                        while (true) {
-                            curTimeMillis = System.currentTimeMillis();
-
-                            try {
-                                Thread.sleep(10);
-                            }
-                            catch (InterruptedException ignored) {
-                                break;
-                            }
+                timer = new IgniteThread(igniteInstanceName, "ignite-clock", () -> {
+                    while (!IgniteThread.currentThread().isInterrupted()) {
+                        curTimeMillis = System.currentTimeMillis();
+
+                        try {
+                            Thread.sleep(10);
+                        }
+                        catch (InterruptedException ignored) {
+                            break;
                         }
                     }
-                }, "ignite-clock");
+                });
 
                 timer.setDaemon(true);
 
diff --git a/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java b/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java
index 9c2e7590c8cba..173b66a84a142 100644
--- a/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java
+++ b/modules/commons/src/main/java/org/apache/ignite/thread/IgniteThread.java
@@ -241,6 +241,22 @@ public static String createName(long num, String threadName, String igniteInstan
         return threadName + "-#" + num + (igniteInstanceName != null ? '%' + igniteInstanceName + '%' : "");
     }
 
+    /**
+     * @param threadId Thread ID.
+     * @return Thread name if found.
+     */
+    public static String resolveName(long threadId) {
+        Thread[] threads = new Thread[Thread.activeCount()];
+
+        int cnt = Thread.enumerate(threads);
+
+        for (int i = 0; i < cnt; i++)
+            if (threads[i].getId() == threadId)
+                return threads[i].getName();
+
+        return "<failed to find active thread " + threadId + '>';
+    }
+
     /** {@inheritDoc} */
     @Override public String toString() {
         return S.toString(IgniteThread.class, this, "name", getName());
diff --git a/modules/core/src/main/java/org/apache/ignite/failure/RestartProcessFailureHandler.java b/modules/core/src/main/java/org/apache/ignite/failure/RestartProcessFailureHandler.java
index 299b8afbb7b57..b74dbe7aaa998 100644
--- a/modules/core/src/main/java/org/apache/ignite/failure/RestartProcessFailureHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/failure/RestartProcessFailureHandler.java
@@ -22,6 +22,7 @@
 import org.apache.ignite.internal.util.typedef.G;
 import org.apache.ignite.internal.util.typedef.internal.S;
 import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.thread.IgniteThread;
 
 /**
  * This handler could be used only with ignite.(sh|bat) script.
@@ -30,16 +31,11 @@
 public class RestartProcessFailureHandler extends AbstractFailureHandler {
     /** {@inheritDoc} */
     @Override protected boolean handle(Ignite ignite, FailureContext failureCtx) {
-        new Thread(
-            new Runnable() {
-                @Override public void run() {
-                    U.error(ignite.log(), "Restarting JVM on Ignite failure: [failureCtx=" + failureCtx + ']');
+        new IgniteThread(ignite.name(), "node-restarter", () -> {
+            U.error(ignite.log(), "Restarting JVM on Ignite failure: [failureCtx=" + failureCtx + ']');
 
-                    G.restart(true);
-                }
-            },
-            "node-restarter"
-        ).start();
+            G.restart(true);
+        }).start();
 
         return true;
     }
diff --git a/modules/core/src/main/java/org/apache/ignite/failure/StopNodeFailureHandler.java b/modules/core/src/main/java/org/apache/ignite/failure/StopNodeFailureHandler.java
index 79f6beecf0999..9fcfd9b88a56b 100644
--- a/modules/core/src/main/java/org/apache/ignite/failure/StopNodeFailureHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/failure/StopNodeFailureHandler.java
@@ -21,6 +21,7 @@
 import org.apache.ignite.internal.IgnitionEx;
 import org.apache.ignite.internal.util.typedef.internal.S;
 import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.thread.IgniteThread;
 
 /**
  * Handler will stop node in case of critical error using {@code IgnitionEx.stop(nodeName, true, true)} call.
@@ -28,16 +29,11 @@
 public class StopNodeFailureHandler extends AbstractFailureHandler {
     /** {@inheritDoc} */
     @Override public boolean handle(Ignite ignite, FailureContext failureCtx) {
-        new Thread(
-            new Runnable() {
-                @Override public void run() {
-                    U.error(ignite.log(), "Stopping local node on Ignite failure: [failureCtx=" + failureCtx + ']');
+        new IgniteThread(ignite.name(), "node-stopper", () -> {
+            U.error(ignite.log(), "Stopping local node on Ignite failure: [failureCtx=" + failureCtx + ']');
 
-                    IgnitionEx.stop(ignite.name(), true, null, true);
-                }
-            },
-            "node-stopper"
-        ).start();
+            IgnitionEx.stop(ignite.name(), true, null, true);
+        }).start();
 
         return true;
     }
diff --git a/modules/core/src/main/java/org/apache/ignite/failure/StopNodeOrHaltFailureHandler.java b/modules/core/src/main/java/org/apache/ignite/failure/StopNodeOrHaltFailureHandler.java
index b72b120ec5846..91212ce34c690 100644
--- a/modules/core/src/main/java/org/apache/ignite/failure/StopNodeOrHaltFailureHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/failure/StopNodeOrHaltFailureHandler.java
@@ -25,6 +25,7 @@
 import org.apache.ignite.internal.IgnitionEx;
 import org.apache.ignite.internal.util.typedef.internal.S;
 import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.thread.IgniteThread;
 
 /**
  * Handler will try to stop node if {@code tryStop} value is {@code true}.
@@ -61,36 +62,26 @@ public StopNodeOrHaltFailureHandler(boolean tryStop, long timeout) {
         if (tryStop) {
             final CountDownLatch latch = new CountDownLatch(1);
 
-            new Thread(
-                new Runnable() {
-                    @Override public void run() {
-                        U.error(log, "Stopping local node on Ignite failure: [failureCtx=" + failureCtx + ']');
+            new IgniteThread(ignite.name(), "node-stopper", () -> {
+                U.error(log, "Stopping local node on Ignite failure: [failureCtx=" + failureCtx + ']');
 
-                        IgnitionEx.stop(ignite.name(), true, null, true);
+                IgnitionEx.stop(ignite.name(), true, null, true);
 
-                        latch.countDown();
-                    }
-                },
-                "node-stopper"
-            ).start();
-
-            new Thread(
-                new Runnable() {
-                    @Override public void run() {
-                        try {
-                            if (!latch.await(timeout, TimeUnit.MILLISECONDS)) {
-                                U.error(log, "Stopping local node timeout, JVM will be halted.");
-
-                                Runtime.getRuntime().halt(Ignition.KILL_EXIT_CODE);
-                            }
-                        }
-                        catch (InterruptedException e) {
-                            // No-op.
-                        }
+                latch.countDown();
+            }).start();
+
+            new IgniteThread(ignite.name(), "jvm-halt-on-stop-timeout", () -> {
+                try {
+                    if (!latch.await(timeout, TimeUnit.MILLISECONDS)) {
+                        U.error(log, "Stopping local node timeout, JVM will be halted.");
+
+                        Runtime.getRuntime().halt(Ignition.KILL_EXIT_CODE);
                     }
-                },
-                "jvm-halt-on-stop-timeout"
-            ).start();
+                }
+                catch (InterruptedException e) {
+                    // No-op.
+                }
+            }).start();
         }
         else {
             U.error(log, "JVM will be halted immediately due to the failure: [failureCtx=" + failureCtx + ']');
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
index 9d60202d7e1c2..e30b0c453a7c5 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
@@ -218,6 +218,7 @@
 import org.apache.ignite.spi.discovery.isolated.IsolatedDiscoverySpi;
 import org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode;
 import org.apache.ignite.spi.tracing.TracingConfigurationManager;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -902,7 +903,7 @@ public void start(
         log = (GridLoggerProxy)cfg.getGridLogger().getLogger(
             getClass().getName() + (igniteInstanceName != null ? '%' + igniteInstanceName : ""));
 
-        longJVMPauseDetector = new LongJVMPauseDetector(log);
+        longJVMPauseDetector = new LongJVMPauseDetector(igniteInstanceName, log);
 
         longJVMPauseDetector.start();
 
@@ -946,7 +947,7 @@ public void start(
 
             startProcessor(clusterProc);
 
-            U.onGridStart();
+            U.onGridStart(igniteInstanceName);
 
             // Start and configure resource processor first as it contains resources used
             // by all other managers and processors.
@@ -3182,11 +3183,11 @@ public void onReconnected(final boolean clusterRestarted) {
 
                             reconnectState.firstReconnectFut.onDone(e);
 
-                            new Thread(() -> {
+                            new IgniteThread(igniteInstanceName, "node-stopper", () -> {
                                 U.error(log, "Stopping the node after a failed reconnect attempt.");
 
                                 close();
-                            }, "node-stopper").start();
+                            }).start();
                         }
                         else {
                             assert ctx.discovery().reconnectSupported();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
index 2086cbe0a044a..7cb7de2dde72a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
@@ -1753,17 +1753,17 @@ private void start0(GridStartContext startCtx, IgniteConfiguration cfg, TimeBag
             // Do NOT set it up only if IGNITE_NO_SHUTDOWN_HOOK=TRUE is provided.
             if (!IgniteSystemProperties.getBoolean(IGNITE_NO_SHUTDOWN_HOOK, false)) {
                 try {
-                    Runtime.getRuntime().addShutdownHook(shutdownHook = new Thread("shutdown-hook") {
-                        @Override public void run() {
-                            if (log.isInfoEnabled())
-                                log.info("Invoking shutdown hook...");
+                    shutdownHook = new IgniteThread(cfg.getIgniteInstanceName(), "shutdown-hook", () -> {
+                        if (log.isInfoEnabled())
+                            log.info("Invoking shutdown hook...");
 
-                            IgniteNamedInstance ignite = IgniteNamedInstance.this;
+                        IgniteNamedInstance ignite = IgniteNamedInstance.this;
 
-                            ignite.stop(true, null);
-                        }
+                        ignite.stop(true, null);
                     });
 
+                    Runtime.getRuntime().addShutdownHook(shutdownHook);
+
                     if (log.isDebugEnabled())
                         log.debug("Shutdown hook is installed.");
                 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/LongJVMPauseDetector.java b/modules/core/src/main/java/org/apache/ignite/internal/LongJVMPauseDetector.java
index e640ea8c3f96c..aa9d6abb77557 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/LongJVMPauseDetector.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/LongJVMPauseDetector.java
@@ -26,6 +26,7 @@
 import org.apache.ignite.internal.util.tostring.GridToStringInclude;
 import org.apache.ignite.internal.util.typedef.internal.S;
 import org.apache.ignite.lang.IgniteBiTuple;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.Nullable;
 
 import static org.apache.ignite.IgniteSystemProperties.IGNITE_JVM_PAUSE_DETECTOR_DISABLED;
@@ -69,6 +70,9 @@ public class LongJVMPauseDetector {
     /** Disabled flag. */
     private static final boolean DISABLED = getBoolean(IGNITE_JVM_PAUSE_DETECTOR_DISABLED);
 
+    /** */
+    private final String igniteInstanceName;
+
     /** Logger. */
     private final IgniteLogger log;
 
@@ -93,9 +97,11 @@ public class LongJVMPauseDetector {
     private final long[] longPausesDurations = new long[EVT_CNT];
 
     /**
+     * @param igniteInstanceName Ignite instance name.
      * @param log Logger.
      */
-    public LongJVMPauseDetector(IgniteLogger log) {
+    public LongJVMPauseDetector(String igniteInstanceName, IgniteLogger log) {
+        this.igniteInstanceName = igniteInstanceName;
         this.log = log;
     }
 
@@ -110,57 +116,56 @@ public void start() {
             return;
         }
 
-        final Thread worker = new Thread("jvm-pause-detector-worker") {
-
-            @Override public void run() {
-                synchronized (LongJVMPauseDetector.this) {
-                    lastWakeUpTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime());
-                }
+        final Thread worker = new IgniteThread(igniteInstanceName, "jvm-pause-detector-worker", () -> {
+            synchronized (this) {
+                lastWakeUpTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime());
+            }
 
-                if (log.isDebugEnabled())
-                    log.debug(getName() + " has been started.");
+            if (log.isDebugEnabled())
+                log.debug(Thread.currentThread().getName() + " has been started.");
 
-                while (true) {
-                    try {
-                        Thread.sleep(PRECISION);
+            while (true) {
+                try {
+                    Thread.sleep(PRECISION);
 
-                        final long now = TimeUnit.NANOSECONDS.toMillis(System.nanoTime());
-                        final long pause = now - PRECISION - lastWakeUpTime;
+                    final long now = TimeUnit.NANOSECONDS.toMillis(System.nanoTime());
+                    final long pause = now - PRECISION - lastWakeUpTime;
 
-                        if (pause >= THRESHOLD) {
-                            log.warning("Possible too long JVM pause: " + pause + " milliseconds.");
+                    if (pause >= THRESHOLD) {
+                        log.warning("Possible too long JVM pause: " + pause + " milliseconds.");
 
-                            synchronized (LongJVMPauseDetector.this) {
-                                final int next = (int)(longPausesCnt % EVT_CNT);
+                        synchronized (this) {
+                            final int next = (int)(longPausesCnt % EVT_CNT);
 
-                                longPausesCnt++;
+                            longPausesCnt++;
 
-                                longPausesTotalDuration += pause;
+                            longPausesTotalDuration += pause;
 
-                                longPausesTimestamps[next] = now;
+                            longPausesTimestamps[next] = now;
 
-                                longPausesDurations[next] = pause;
+                            longPausesDurations[next] = pause;
 
-                                lastWakeUpTime = now;
-                            }
+                            lastWakeUpTime = now;
                         }
-                        else {
-                            synchronized (LongJVMPauseDetector.this) {
-                                lastWakeUpTime = now;
-                            }
+                    }
+                    else {
+                        synchronized (this) {
+                            lastWakeUpTime = now;
                         }
                     }
-                    catch (InterruptedException e) {
-                        if (workerRef.compareAndSet(this, null))
-                            log.error(getName() + " has been interrupted.", e);
-                        else if (log.isDebugEnabled())
-                            log.debug(getName() + " has been stopped.");
+                }
+                catch (InterruptedException e) {
+                    Thread locThread = Thread.currentThread();
 
-                        break;
-                    }
+                    if (workerRef.compareAndSet(locThread, null))
+                        log.error(locThread.getName() + " has been interrupted.", e);
+                    else if (log.isDebugEnabled())
+                        log.debug(locThread.getName() + " has been stopped.");
+
+                    break;
                 }
             }
-        };
+        });
 
         if (!workerRef.compareAndSet(null, worker)) {
             log.warning(LongJVMPauseDetector.class.getSimpleName() + " already started!");
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cluster/IgniteKillTask.java b/modules/core/src/main/java/org/apache/ignite/internal/cluster/IgniteKillTask.java
index cdf580d302c31..66d14eca4b624 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/cluster/IgniteKillTask.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/cluster/IgniteKillTask.java
@@ -19,6 +19,7 @@
 
 import java.util.List;
 import java.util.Map;
+import org.apache.ignite.Ignite;
 import org.apache.ignite.cluster.ClusterNode;
 import org.apache.ignite.compute.ComputeJob;
 import org.apache.ignite.compute.ComputeJobAdapter;
@@ -28,6 +29,8 @@
 import org.apache.ignite.internal.processors.task.GridInternal;
 import org.apache.ignite.internal.util.typedef.G;
 import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.resources.IgniteInstanceResource;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -72,22 +75,16 @@ private class IgniteKillJob extends ComputeJobAdapter {
         /** */
         private static final long serialVersionUID = 0L;
 
+        /** */
+        @IgniteInstanceResource
+        private transient Ignite ignite;
+
         /** {@inheritDoc} */
         @Override public Object execute() {
             if (restart)
-                new Thread(new Runnable() {
-                    @Override public void run() {
-                        G.restart(true);
-                    }
-                },
-                "ignite-restarter").start();
+                new IgniteThread(ignite.name(), "ignite-restarter", () -> G.restart(true)).start();
             else
-                new Thread(new Runnable() {
-                    @Override public void run() {
-                        G.kill(true);
-                    }
-                },
-                "ignite-stopper").start();
+                new IgniteThread(ignite.name(), "ignite-stopper", () -> G.kill(true)).start();
 
             return null;
         }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheDiagnosticManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheDiagnosticManager.java
index 0d06fef71b057..8640da2427cf8 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheDiagnosticManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheDiagnosticManager.java
@@ -38,9 +38,9 @@ public class CacheDiagnosticManager extends GridCacheSharedManagerAdapter {
     @Override protected void start0() throws IgniteCheckedException {
         super.start0();
 
-        String name = U.maskForFileName(cctx.kernalContext().pdsFolderResolver().resolveFolders().consistentId().toString());
+        String nodeId = U.maskForFileName(cctx.kernalContext().pdsFolderResolver().resolveFolders().consistentId().toString());
 
-        pageLockTrackerManager = new PageLockTrackerManager(log, name);
+        pageLockTrackerManager = new PageLockTrackerManager(cctx.kernalContext().igniteInstanceName(), nodeId, log);
 
         pageLockTrackerManager.start();
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java
index b94e6904110b1..4c98c684e872f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/near/GridNearTxLocal.java
@@ -106,6 +106,7 @@
 import org.apache.ignite.lang.IgniteBiClosure;
 import org.apache.ignite.lang.IgniteUuid;
 import org.apache.ignite.plugin.security.SecurityPermission;
+import org.apache.ignite.thread.IgniteThread;
 import org.apache.ignite.transactions.TransactionConcurrency;
 import org.apache.ignite.transactions.TransactionException;
 import org.apache.ignite.transactions.TransactionIsolation;
@@ -4851,7 +4852,7 @@ protected abstract class FinishClosure<T> implements IgniteBiClosure<T, Exceptio
     /** {@inheritDoc} */
     @Override public String toString() {
         return S.toString(GridNearTxLocal.class, this,
-            "thread", IgniteUtils.threadName(threadId),
+            "thread", IgniteThread.resolveName(threadId),
             "mappings", mappings,
             "super", super.toString());
     }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java
index b9a9642ba445f..102469f82f641 100755
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java
@@ -864,6 +864,7 @@ private void readMetastore() throws IgniteCheckedException {
                         prepareCacheDefragmentation(fromStore(task).cacheNames());
 
                         return new DefragmentationWorkflowCallback(
+                            cctx.igniteInstanceName(),
                             cctx.kernalContext()::log,
                             defrgMgr,
                             cctx.kernalContext().failure()
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/DefragmentationWorkflowCallback.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/DefragmentationWorkflowCallback.java
index b3bbe5176c9b1..63a8092ebe715 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/DefragmentationWorkflowCallback.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/DefragmentationWorkflowCallback.java
@@ -41,16 +41,22 @@ public class DefragmentationWorkflowCallback implements MaintenanceWorkflowCallb
     /** Failure processor. */
     private final FailureProcessor failureProc;
 
+    /** */
+    private final String igniteInstanceName;
+
     /**
+     * @param igniteInstanceName Ignite instance name.
      * @param logProvider Logger provider.
      * @param defrgMgr Defragmentation manager.
      * @param failureProc Failure processor.
      */
     public DefragmentationWorkflowCallback(
+        String igniteInstanceName,
         Function<Class<?>, IgniteLogger> logProvider,
         CachePartitionDefragmentationManager defrgMgr,
         FailureProcessor failureProc
     ) {
+        this.igniteInstanceName = igniteInstanceName;
         this.defrgMgr = defrgMgr;
         this.logProvider = logProvider;
         this.failureProc = failureProc;
@@ -68,6 +74,6 @@ public DefragmentationWorkflowCallback(
 
     /** {@inheritDoc} */
     @Override public @Nullable MaintenanceAction<Boolean> automaticAction() {
-        return new ExecuteDefragmentationAction(logProvider, defrgMgr, failureProc);
+        return new ExecuteDefragmentationAction(igniteInstanceName, logProvider, defrgMgr, failureProc);
     }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/ExecuteDefragmentationAction.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/ExecuteDefragmentationAction.java
index 0758772fc09e4..3c393cbf4964d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/ExecuteDefragmentationAction.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/maintenance/ExecuteDefragmentationAction.java
@@ -26,6 +26,7 @@
 import org.apache.ignite.internal.processors.cache.persistence.defragmentation.CachePartitionDefragmentationManager;
 import org.apache.ignite.internal.processors.failure.FailureProcessor;
 import org.apache.ignite.maintenance.MaintenanceAction;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -42,16 +43,22 @@ class ExecuteDefragmentationAction implements MaintenanceAction<Boolean> {
     /** Failure processor. */
     private final FailureProcessor failureProc;
 
+    /** */
+    private final String igniteInstanceName;
+
     /**
+     * @param igniteInstanceName Ignite instance name.
      * @param logFunction Logger provider.
      * @param defrgMgr Defragmentation manager.
      * @param failureProc Failure processor.
      */
     public ExecuteDefragmentationAction(
+        String igniteInstanceName,
         Function<Class<?>, IgniteLogger> logFunction,
         CachePartitionDefragmentationManager defrgMgr,
         FailureProcessor failureProc
     ) {
+        this.igniteInstanceName = igniteInstanceName;
         this.log = logFunction.apply(ExecuteDefragmentationAction.class);
         this.defrgMgr = defrgMgr;
         this.failureProc = failureProc;
@@ -68,7 +75,7 @@ public ExecuteDefragmentationAction(
             return false;
         }
 
-        Thread defrgThread = new Thread(() -> {
+        Thread defrgThread = new IgniteThread(igniteInstanceName, "defragmentation-thread", () -> {
             try {
                 defrgMgr.executeDefragmentation();
             }
@@ -80,8 +87,6 @@ public ExecuteDefragmentationAction(
             }
         });
 
-        defrgThread.setName("defragmentation-thread");
-
         defrgThread.setDaemon(true);
 
         defrgThread.start();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManager.java
index 7b60bf3a83c1c..e8878e8757b96 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManager.java
@@ -20,7 +20,6 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Set;
-import java.util.UUID;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
 import org.apache.ignite.IgniteLogger;
@@ -96,21 +95,15 @@ public class PageLockTrackerManager implements LifecycleAware {
     private final boolean trackingEnabled;
 
     /**
-     * Default constructor.
-     */
-    public PageLockTrackerManager(IgniteLogger log) {
-        this(log, "mgr_" + UUID.randomUUID());
-    }
-
-    /**
-     * @param log Ignite logger.
+     * @param igniteInstanceName Ignite instance name.
      * @param managerNameId Manager name.
+     * @param log Ignite logger.
      */
-    public PageLockTrackerManager(IgniteLogger log, String managerNameId) {
+    public PageLockTrackerManager(String igniteInstanceName, String managerNameId, IgniteLogger log) {
         this.trackingEnabled = getInteger(IGNITE_PAGE_LOCK_TRACKER_TYPE, HEAP_LOG) != -1;
         this.managerNameId = managerNameId;
         this.mxBean = new PageLockTrackerMXBeanImpl(this, memoryCalculator);
-        this.sharedPageLockTracker = new SharedPageLockTracker(this::onHangThreads, memoryCalculator);
+        this.sharedPageLockTracker = new SharedPageLockTracker(igniteInstanceName, this::onHangThreads, memoryCalculator, log);
         this.log = log;
 
         memoryCalculator.onHeapAllocated(OVERHEAD_SIZE);
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTracker.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTracker.java
index 1158bf6ef62e9..cb5796d946373 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTracker.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTracker.java
@@ -30,10 +30,12 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.apache.ignite.IgniteInterruptedException;
+import org.apache.ignite.IgniteLogger;
 import org.apache.ignite.IgniteSystemProperties;
 import org.apache.ignite.internal.processors.cache.persistence.tree.util.PageLockListener;
 import org.apache.ignite.internal.util.typedef.F;
-import org.apache.ignite.internal.util.worker.CycleThread;
+import org.apache.ignite.internal.util.worker.GridWorker;
+import org.apache.ignite.thread.IgniteThread;
 
 import static org.apache.ignite.IgniteSystemProperties.IGNITE_PAGE_LOCK_TRACKER_CHECK_INTERVAL;
 import static org.apache.ignite.IgniteSystemProperties.getInteger;
@@ -69,7 +71,7 @@ public class SharedPageLockTracker {
     private final Map<String, Integer> structureNameToId = new ConcurrentHashMap<>();
 
     /** Thread for clean terminated threads from map. */
-    private final TimeOutWorker timeOutWorker;
+    private final IgniteThread timeOutWorker;
 
     /** */
     private Map<Long, PageLockThreadState> prevThreadsState = new HashMap<>();
@@ -84,29 +86,36 @@ public class SharedPageLockTracker {
     private final ThreadLocal<PageLockTracker<?>> lockTracker = ThreadLocal.withInitial(this::createTracker);
 
     /** */
-    public SharedPageLockTracker() {
-        this(ids -> {}, new MemoryCalculator());
-    }
-
-    /** */
-    public SharedPageLockTracker(Consumer<Set<PageLockThreadState>> hangThreadsCallBack, MemoryCalculator memCalc) {
+    public SharedPageLockTracker(
+        String igniteInstanceName,
+        Consumer<Set<PageLockThreadState>> hangThreadsCallBack,
+        MemoryCalculator memCalc,
+        IgniteLogger log
+    ) {
         this(
+            igniteInstanceName,
             1000,
             getInteger(IGNITE_PAGE_LOCK_TRACKER_CHECK_INTERVAL, DFLT_PAGE_LOCK_TRACKER_CHECK_INTERVAL),
             hangThreadsCallBack,
-            memCalc
+            memCalc,
+            log
         );
     }
 
     /** */
     public SharedPageLockTracker(
+        String igniteInstanceName,
         int threadLimits,
         int timeOutWorkerInterval,
         Consumer<Set<PageLockThreadState>> hangThreadsCallBack,
-        MemoryCalculator memCalc
+        MemoryCalculator memCalc,
+        IgniteLogger log
     ) {
         this.threadLimits = threadLimits;
-        this.timeOutWorker = new TimeOutWorker(timeOutWorkerInterval);
+        this.timeOutWorker = new IgniteThread(
+            igniteInstanceName,
+            "page-lock-timeout-tracker",
+            new TimeOutWorker(igniteInstanceName, timeOutWorkerInterval, log));
         this.hangThreadsCallBack = hangThreadsCallBack;
         this.memCalc = memCalc;
 
@@ -320,17 +329,33 @@ public void stop() {
     /**
      *
      */
-    private class TimeOutWorker extends CycleThread {
+    private class TimeOutWorker extends GridWorker {
+        /** Sleep interval before each iteration. */
+        private final long sleepInterval;
 
         /**
+         * Creates new timeout worker with given parameters.
          *
+         * @param sleepInterval sleep interval before each iteration
          */
-        TimeOutWorker(long interval) {
-            super("page-lock-tracker-timeout", interval);
+        protected TimeOutWorker(String igniteInstanceName, long sleepInterval, IgniteLogger log) {
+            super(igniteInstanceName, "page-lock-timeout-tracker-worker", log);
+
+            this.sleepInterval = sleepInterval;
         }
 
         /** {@inheritDoc} */
-        @Override public void iteration() {
+        @SuppressWarnings("BusyWait")
+        @Override public final void body() throws InterruptedException {
+            while (!runner().isInterrupted()) {
+                Thread.sleep(sleepInterval);
+
+                iteration();
+            }
+        }
+
+        /** */
+        private void iteration() {
             cleanTerminatedThreads();
 
             if (hangThreadsCallBack != null) {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/wal/reader/StandaloneGridKernalContext.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/wal/reader/StandaloneGridKernalContext.java
index c14efa3d123b5..7cebeaca6a894 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/wal/reader/StandaloneGridKernalContext.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/wal/reader/StandaloneGridKernalContext.java
@@ -730,7 +730,7 @@ private void setField(IgniteEx kernal, String name, Object val) throws NoSuchFie
 
     /** {@inheritDoc} */
     @Override public LongJVMPauseDetector longJvmPauseDetector() {
-        return new LongJVMPauseDetector(log);
+        return new LongJVMPauseDetector("standalone-ignite-kernal", log);
     }
 
     /** {@inheritDoc} */
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cluster/GridUpdateNotifier.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cluster/GridUpdateNotifier.java
index 0ace54d6e5410..57a219fc128e1 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cluster/GridUpdateNotifier.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cluster/GridUpdateNotifier.java
@@ -26,6 +26,7 @@
 import org.apache.ignite.internal.IgniteKernal;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.internal.util.worker.GridWorker;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -90,36 +91,34 @@ class GridUpdateNotifier {
      * @param ver Compound Ignite version.
      * @param reportOnlyNew Whether or not to report only new version.
      * @param updatesChecker Service for getting Ignite updates
-     * @throws IgniteCheckedException If failed.
      */
     GridUpdateNotifier(
         String igniteInstanceName,
         String ver,
         boolean reportOnlyNew,
         HttpIgniteUpdatesChecker updatesChecker
-    ) throws IgniteCheckedException {
+    ) {
         this.ver = ver;
         this.igniteInstanceName = igniteInstanceName == null ? "null" : igniteInstanceName;
         this.updatesChecker = updatesChecker;
         this.reportOnlyNew = reportOnlyNew;
 
-        workerThread = new Thread(new Runnable() {
-            @Override public void run() {
-                try {
-                    while (!Thread.currentThread().isInterrupted()) {
-                        Runnable cmd0 = cmd.getAndSet(null);
+        workerThread = new IgniteThread(igniteInstanceName, "upd-ver-checker", () -> {
+            while (!Thread.currentThread().isInterrupted()) {
+                Runnable cmd0 = cmd.getAndSet(null);
 
-                        if (cmd0 != null)
-                            cmd0.run();
-                        else
-                            Thread.sleep(WORKER_THREAD_SLEEP_TIME);
+                if (cmd0 != null)
+                    cmd0.run();
+                else {
+                    try {
+                        Thread.sleep(WORKER_THREAD_SLEEP_TIME);
+                    }
+                    catch (InterruptedException ignored) {
+                        break;
                     }
-                }
-                catch (InterruptedException ignore) {
-                    // No-op.
                 }
             }
-        }, "upd-ver-checker");
+        });
 
         workerThread.setDaemon(true);
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
index 0aa0dcf981e67..c8ea0134a6ad5 100755
--- a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
@@ -6689,22 +6689,6 @@ public static boolean isToStringMethod(Method mtd) {
         return toStringMtd.equals(mtd);
     }
 
-    /**
-     * @param threadId Thread ID.
-     * @return Thread name if found.
-     */
-    public static String threadName(long threadId) {
-        Thread[] threads = new Thread[Thread.activeCount()];
-
-        int cnt = Thread.enumerate(threads);
-
-        for (int i = 0; i < cnt; i++)
-            if (threads[i].getId() == threadId)
-                return threads[i].getName();
-
-        return "<failed to find active thread " + threadId + '>';
-    }
-
     /**
      * @param t0 Comparable object.
      * @param t1 Comparable object.
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/worker/CycleThread.java b/modules/core/src/main/java/org/apache/ignite/internal/util/worker/CycleThread.java
deleted file mode 100644
index 8c24fdcfc29e2..0000000000000
--- a/modules/core/src/main/java/org/apache/ignite/internal/util/worker/CycleThread.java
+++ /dev/null
@@ -1,63 +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.util.worker;
-
-import org.jetbrains.annotations.NotNull;
-
-/**
- * Thread wrapper for standart cycle operations.
- */
-public abstract class CycleThread extends Thread {
-
-    /** Sleep interval before each iteration. */
-    private final long sleepInterval;
-
-    /**
-     * Creates new cycle thread with given parameters.
-     *
-     * @param name thread name
-     * @param sleepInterval sleep interval before each iteration
-     */
-    protected CycleThread(@NotNull String name, long sleepInterval) {
-        super(name);
-
-        this.sleepInterval = sleepInterval;
-    }
-
-    /** {@inheritDoc} */
-    @SuppressWarnings("BusyWait")
-    @Override public final void run() {
-        try {
-            while (!isInterrupted()) {
-                Thread.sleep(sleepInterval);
-
-                iteration();
-            }
-        }
-        catch (InterruptedException e) {
-            // No-op
-        }
-    }
-
-    /**
-     * Called on each iteration.
-     *
-     * @throws InterruptedException Еhrows if no specific handling required.
-     */
-    public abstract void iteration() throws InterruptedException;
-}
diff --git a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java
index c0a9e39ac5a26..2d2480f01f3cb 100644
--- a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java
@@ -159,6 +159,7 @@
 import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryServerOnlyCustomEventMessage;
 import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryStatusCheckMessage;
 import org.apache.ignite.spi.tracing.SpanStatus;
+import org.apache.ignite.thread.IgniteThread;
 import org.jetbrains.annotations.Nullable;
 
 import static java.util.stream.Collectors.collectingAndThen;
@@ -3041,20 +3042,18 @@ private void addToQueue(TcpDiscoveryAbstractMessage msg, boolean addFirst) {
                         U.error(log, "TcpDiscoverSpi's message worker thread failed abnormally. " +
                             "Stopping the node in order to prevent cluster wide instability.", e);
 
-                        new Thread(new Runnable() {
-                            @Override public void run() {
-                                try {
-                                    IgnitionEx.stop(ignite.name(), true, ShutdownPolicy.IMMEDIATE, true);
+                        new IgniteThread(igniteInstanceName(), "node-stop-thread", () -> {
+                            try {
+                                IgnitionEx.stop(ignite.name(), true, ShutdownPolicy.IMMEDIATE, true);
 
-                                    U.log(log, "Stopped the node successfully in response to TcpDiscoverySpi's " +
-                                        "message worker thread abnormal termination.");
-                                }
-                                catch (Throwable e) {
-                                    U.error(log, "Failed to stop the node in response to TcpDiscoverySpi's " +
-                                        "message worker thread abnormal termination.", e);
-                                }
+                                U.log(log, "Stopped the node successfully in response to TcpDiscoverySpi's " +
+                                    "message worker thread abnormal termination.");
+                            }
+                            catch (Throwable nodeStopErr) {
+                                U.error(log, "Failed to stop the node in response to TcpDiscoverySpi's " +
+                                    "message worker thread abnormal termination.", nodeStopErr);
                             }
-                        }, "node-stop-thread").start();
+                        }).start();
                     }
                 }
 
@@ -7291,7 +7290,7 @@ private InetSocketAddress checkConnection(TcpDiscoveryNode node, int timeout) {
 
                 --threadsLeft;
 
-                utilityPool.execute(new Thread() {
+                utilityPool.execute(new Runnable() {
                     private final int addrsToCheck = addrPerThread;
 
                     /** */
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/LongJVMPauseDetectorTest.java b/modules/core/src/test/java/org/apache/ignite/internal/LongJVMPauseDetectorTest.java
index 616c570755c0b..45b436c8dabff 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/LongJVMPauseDetectorTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/LongJVMPauseDetectorTest.java
@@ -17,8 +17,10 @@
 
 package org.apache.ignite.internal;
 
+import java.util.regex.Pattern;
 import org.apache.ignite.configuration.IgniteConfiguration;
-import org.apache.ignite.testframework.GridStringLogger;
+import org.apache.ignite.testframework.ListeningTestLogger;
+import org.apache.ignite.testframework.LogListener;
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 
@@ -27,20 +29,27 @@
  */
 public class LongJVMPauseDetectorTest extends GridCommonAbstractTest {
     /** */
-    private GridStringLogger strLog;
+    private static ListeningTestLogger listeningTestLogger;
 
     /** {@inheritDoc} */
     @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
-        IgniteConfiguration cfg = super.getConfiguration(gridName);
+        return super.getConfiguration(gridName)
+            .setGridLogger(listeningTestLogger);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        super.beforeTest();
 
-        if (strLog != null)
-            cfg.setGridLogger(strLog);
+        setLoggerDebugLevel();
 
-        return cfg;
+        listeningTestLogger = new ListeningTestLogger(log);
     }
 
     /** {@inheritDoc} */
     @Override protected void afterTest() throws Exception {
+        super.afterTest();
+
         stopAllGrids();
     }
 
@@ -49,13 +58,14 @@ public class LongJVMPauseDetectorTest extends GridCommonAbstractTest {
      */
     @Test
     public void testJulMessage() throws Exception {
-        this.strLog = new GridStringLogger(true);
+        // We should discard ring check latency on server node.
+        LogListener lsnr = LogListener.matches("LongJVMPauseDetector was successfully started").times(1).build();
 
-        strLog.logLength(300000);
+        listeningTestLogger.registerListener(lsnr);
 
         startGrid(0);
 
-        assertTrue(strLog.toString().contains("LongJVMPauseDetector was successfully started"));
+        assertTrue(lsnr.check());
     }
 
     /**
@@ -63,17 +73,16 @@ public void testJulMessage() throws Exception {
      */
     @Test
     public void testStopWorkerThread() throws Exception {
-        strLog = new GridStringLogger(true);
+        LogListener stopLsnr = LogListener.matches(Pattern.compile("jvm-pause-detector-worker-.* has been stopped\\.")).times(1).build();
+        LogListener interruptLsnr = LogListener.matches(Pattern.compile("jvm-pause-detector-worker-.* has been interrupted\\.")).build();
 
-        strLog.logLength(300_000);
+        listeningTestLogger.registerListener(stopLsnr);
+        listeningTestLogger.registerListener(interruptLsnr);
 
         startGrid(0);
-
         stopGrid(0);
 
-        String log = strLog.toString();
-
-        assertFalse(log.contains("jvm-pause-detector-worker has been interrupted."));
-        assertTrue(log.contains("jvm-pause-detector-worker has been stopped."));
+        assertFalse(interruptLsnr.check());
+        assertTrue(stopLsnr.check());
     }
 }
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManagerTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManagerTest.java
index f8ee79d81871e..08d15e0059d4a 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManagerTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/PageLockTrackerManagerTest.java
@@ -50,7 +50,7 @@ public void testDisableTracking() {
         System.setProperty("IGNITE_PAGE_LOCK_TRACKER_TYPE", String.valueOf(-1));
 
         try {
-            PageLockTrackerManager mgr = new PageLockTrackerManager(new ListeningTestLogger());
+            PageLockTrackerManager mgr = new PageLockTrackerManager("testIgniteInstance", "testManager", new ListeningTestLogger());
 
             PageLockListener pll = mgr.createPageLockTracker("test");
 
@@ -65,7 +65,7 @@ public void testDisableTracking() {
         System.setProperty("IGNITE_PAGE_LOCK_TRACKER_TYPE", String.valueOf(HEAP_LOG));
 
         try {
-            PageLockTrackerManager mgr = new PageLockTrackerManager(new ListeningTestLogger());
+            PageLockTrackerManager mgr = new PageLockTrackerManager("testIgniteInstance", "testManager", new ListeningTestLogger());
 
             PageLockListener pll = mgr.createPageLockTracker("test");
 
@@ -101,7 +101,7 @@ public void testMemoryCalculation0(int type) throws Exception {
         System.setProperty("IGNITE_PAGE_LOCK_TRACKER_CHECK_INTERVAL", String.valueOf(timeOutWorkerInterval));
 
         try {
-            PageLockTrackerManager mgr = new PageLockTrackerManager(new ListeningTestLogger());
+            PageLockTrackerManager mgr = new PageLockTrackerManager("testIgniteInstance", "testManager", new ListeningTestLogger());
 
             mgr.start();
 
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTrackerTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTrackerTest.java
index 9ed00f9f0eb30..4f5981d29d615 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTrackerTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/SharedPageLockTrackerTest.java
@@ -30,6 +30,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.IgniteLogger;
 import org.apache.ignite.internal.IgniteInternalFuture;
 import org.apache.ignite.internal.processors.cache.persistence.tree.util.PageLockListener;
 import org.apache.ignite.internal.util.IgniteUtils;
@@ -112,16 +113,14 @@ public void testTakeDumpByTime() throws Exception {
         doTestTakeDumpByTime(20, 6, time, 8);
     }
 
-    /**
-     *
-     */
+    /** */
     private void doTestTakeDumpByCount(
         int pagesCnt,
         int structuresCnt,
         int dumpCnt,
         int threads
     ) throws IgniteCheckedException, InterruptedException {
-        SharedPageLockTracker sharedPageLockTracker = new SharedPageLockTracker();
+        SharedPageLockTracker sharedPageLockTracker = createSharedPageLockTracker(log);
 
         List<PageMeta> pageMetas = new CopyOnWriteArrayList<>();
 
@@ -209,7 +208,7 @@ private void doTestTakeDumpByTime(
         int dumpTime,
         int threads
     ) throws IgniteCheckedException, InterruptedException {
-        SharedPageLockTracker sharedPageLockTracker = new SharedPageLockTracker();
+        SharedPageLockTracker sharedPageLockTracker = createSharedPageLockTracker(log);
 
         List<PageMeta> pageMetas = new CopyOnWriteArrayList<>();
 
@@ -305,11 +304,16 @@ private void doTestTakeDumpByTime(
     public void testMemoryLeakOnThreadTerminates() throws Exception {
         int threadLimits = 1000;
         int timeOutWorkerInterval = 10_000;
-        Consumer<Set<PageLockThreadState>> hnd = (threads) -> {
-        };
+        Consumer<Set<PageLockThreadState>> hnd = threads -> {};
 
         SharedPageLockTracker sharedPageLockTracker = new SharedPageLockTracker(
-            threadLimits, timeOutWorkerInterval, hnd, new MemoryCalculator());
+            "testIgniteInstance",
+            threadLimits,
+            timeOutWorkerInterval,
+            hnd,
+            new MemoryCalculator(),
+            log
+        );
 
         int threads = 10_000;
 
@@ -410,6 +414,7 @@ public void testAutoDetectHangThreads() throws Exception {
         CountDownLatch awaitLatch = new CountDownLatch(1);
 
         SharedPageLockTracker sharedPageLockTracker = new SharedPageLockTracker(
+            "testIgniteInstance",
             1000,
             10_000,
             hangsThreads -> {
@@ -450,7 +455,9 @@ public void testAutoDetectHangThreads() throws Exception {
                 }
 
                 awaitLatch.countDown();
-            }, new MemoryCalculator()
+            },
+            new MemoryCalculator(),
+            log
         );
 
         int cacheId = 1;
@@ -523,7 +530,7 @@ public void testAutoDetectHangThreads() throws Exception {
      */
     @Test
     public void testCloseListener() {
-        SharedPageLockTracker tracker = new SharedPageLockTracker();
+        SharedPageLockTracker tracker = createSharedPageLockTracker(log);
 
         PageLockListener foo = tracker.registerStructure("foo");
         PageLockListener bar = tracker.registerStructure("bar");
@@ -588,4 +595,9 @@ private PageMeta(
                 '}';
         }
     }
+
+    /** */
+    public static SharedPageLockTracker createSharedPageLockTracker(IgniteLogger log) {
+        return new SharedPageLockTracker("testIgniteInstance", ids -> {}, new MemoryCalculator(), log);
+    }
 }
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToFileDumpProcessorTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToFileDumpProcessorTest.java
index 7ff9b97de00e5..6e77b2930da13 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToFileDumpProcessorTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToFileDumpProcessorTest.java
@@ -27,23 +27,20 @@
 import org.apache.ignite.internal.processors.cache.persistence.diagnostic.pagelocktracker.SharedPageLockTrackerDump;
 import org.apache.ignite.internal.processors.cache.persistence.tree.util.PageLockListener;
 import org.apache.ignite.internal.util.typedef.internal.U;
-import org.junit.After;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.apache.ignite.internal.processors.cache.persistence.diagnostic.pagelocktracker.SharedPageLockTrackerTest.createSharedPageLockTracker;
 
 /**
  *
  */
-public class ToFileDumpProcessorTest {
+public class ToFileDumpProcessorTest extends GridCommonAbstractTest {
     /** */
     private Path file;
 
-    /** */
-    @After
-    public void afterTest() throws IOException {
+    /** {@inheritDoc} */
+    @Override public void afterTest() throws IOException {
         if (file != null)
             Files.delete(file);
     }
@@ -55,7 +52,7 @@ public void toFileDump() throws Exception {
 
         System.out.println("IGNITE_HOME:" + homeDir);
 
-        SharedPageLockTracker pageLockTracker = new SharedPageLockTracker();
+        SharedPageLockTracker pageLockTracker = createSharedPageLockTracker(log);
 
         try (PageLockListener tracker = pageLockTracker.registerStructure("dummy")) {
             tracker.onBeforeReadLock(1, 2, 3);
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToStringDumpHelperTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToStringDumpHelperTest.java
index d0e5ffe98f111..17a1e81db0fb7 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToStringDumpHelperTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/diagnostic/pagelocktracker/dumpprocessors/ToStringDumpHelperTest.java
@@ -28,6 +28,8 @@
 import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
 import org.junit.Test;
 
+import static org.apache.ignite.internal.processors.cache.persistence.diagnostic.pagelocktracker.SharedPageLockTrackerTest.createSharedPageLockTracker;
+
 /**
  * Unit tests for {@link ToStringDumpHelper}.
  */
@@ -38,7 +40,7 @@ public class ToStringDumpHelperTest extends GridCommonAbstractTest {
     /** */
     @Test
     public void toStringSharedPageLockTrackerTest() throws Exception {
-        SharedPageLockTracker pageLockTracker = new SharedPageLockTracker();
+        SharedPageLockTracker pageLockTracker = createSharedPageLockTracker(log);
 
         PageLockListener tracker = pageLockTracker.registerStructure("dummy");
 
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeReplaceRemoveRaceTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeReplaceRemoveRaceTest.java
index 8a4c59c93c4e2..74a18e61f9811 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeReplaceRemoveRaceTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeReplaceRemoveRaceTest.java
@@ -74,7 +74,7 @@ public class BPlusTreeReplaceRemoveRaceTest extends GridCommonAbstractTest {
     @Override protected void beforeTest() throws Exception {
         pageMem = createPageMemory();
 
-        lockTrackerManager = new PageLockTrackerManager(log, "testTreeManager");
+        lockTrackerManager = new PageLockTrackerManager("testIgniteInstance", "testTreeManager", log);
 
         lockTrackerManager.start();
     }
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeSelfTest.java
index 6697225882431..a617a4f361a74 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/database/BPlusTreeSelfTest.java
@@ -170,7 +170,7 @@ protected void assertNoLocks() {
 
         reuseList = createReuseList(CACHE_ID, pageMem, 0, true);
 
-        lockTrackerManager = new PageLockTrackerManager(log, "testTreeManager") {
+        lockTrackerManager = new PageLockTrackerManager("testIgniteInstance", "testTreeManager", log) {
             @Override public PageLockListener createPageLockTracker(String name) {
                 return new TestPageLockListener(super.createPageLockTracker(name));
             }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/GridJavaProcess.java b/modules/core/src/test/java/org/apache/ignite/internal/util/GridJavaProcess.java
similarity index 100%
rename from modules/core/src/main/java/org/apache/ignite/internal/util/GridJavaProcess.java
rename to modules/core/src/test/java/org/apache/ignite/internal/util/GridJavaProcess.java
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java
index 30eb29cde09f0..337dd99ed4f95 100644
--- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java
@@ -74,7 +74,7 @@ public GridTestKernalContext(IgniteLogger log, IgniteConfiguration cfg) {
                 null,
                 null,
                 null,
-                new LongJVMPauseDetector(log)
+                new LongJVMPauseDetector(cfg.getIgniteInstanceName() == null ? "test-ignite-kernal" : cfg.getIgniteInstanceName(), log)
         );
 
         GridTestUtils.setFieldValue(grid(), "cfg", config());