diff --git a/docs/_docs/monitoring-metrics/new-metrics.adoc b/docs/_docs/monitoring-metrics/new-metrics.adoc index 545c0fa8af7b8..4002011a8bd32 100644 --- a/docs/_docs/monitoring-metrics/new-metrics.adoc +++ b/docs/_docs/monitoring-metrics/new-metrics.adoc @@ -803,6 +803,28 @@ Register name: `failure.ignored` The `ignite-cdc.sh` application runs in a separate JVM and exports its own registers, `cdc` and `cdc.consumer`, through the exporters configured in `CdcConfiguration`. See link:persistence/change-data-capture#metrics[Change Data Capture] for the list of metrics. +== Logging + +Counters of log messages passed through the node's logger proxies, grouped by logging level. +Counters are shared across all logger categories of the node and start accumulating when the node's logger proxy is created, before the metrics are registered. + +Register name: `log.count` + +The CDC application also registers these counters in its own metric manager. +Connect to the Ignite node and CDC application separately to read their respective log counters. + +[cols="2,1,3",opts="header"] +|=== +|Name | Type | Description +|trace | long | Number of TRACE messages counted while the TRACE level is enabled. +|debug | long | Number of DEBUG messages counted while the DEBUG level is enabled. +|info | long | Number of INFO messages counted while the INFO level is enabled. +|warning | long | Number of WARN messages passed to the logger. +|error | long | Number of ERROR messages passed to the logger. +|=== + +These counters do not guarantee that messages were written to a file or another destination: the logging backend may apply additional filters. + == Custom Metrics Registers created by the application through `Ignite.metrics()`. Their names start with `custom.`, see link:monitoring-metrics/custom-metrics[Custom Metrics]. diff --git a/modules/core/src/main/java/org/apache/ignite/internal/GridLoggerProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/GridLoggerProxy.java index fb59da99118ba..008dc88d4b3f4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/GridLoggerProxy.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/GridLoggerProxy.java @@ -25,6 +25,9 @@ import java.io.ObjectStreamException; import java.util.Collections; import org.apache.ignite.IgniteLogger; +import org.apache.ignite.internal.processors.metric.GridMetricManager; +import org.apache.ignite.internal.processors.metric.MetricRegistryImpl; +import org.apache.ignite.internal.processors.metric.impl.LongAdderMetric; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.typedef.internal.S; import org.apache.ignite.internal.util.typedef.internal.U; @@ -34,6 +37,7 @@ import static org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_GRID_NAME; import static org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_INSTANCE_NAME; +import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName; /** * @@ -42,6 +46,9 @@ public class GridLoggerProxy implements IgniteLogger, LifecycleAware, Externaliz /** */ private static final long serialVersionUID = 0L; + /** Log messages count metrics registry name. */ + static final String LOG_COUNT_METRICS = metricName("log", "count"); + /** */ private static ThreadLocal> stash = new ThreadLocal>() { @Override protected IgniteBiTuple initialValue() { @@ -62,6 +69,10 @@ public class GridLoggerProxy implements IgniteLogger, LifecycleAware, Externaliz @GridToStringExclude private Object ctgr; + /** Shared log message metrics. */ + @GridToStringExclude + private final LogMetrics metrics; + /** Whether or not to log Ignite instance name. */ private static final boolean logIgniteInstanceName = System.getProperty(IGNITE_LOG_INSTANCE_NAME) != null || System.getProperty(IGNITE_LOG_GRID_NAME) != null; @@ -70,7 +81,7 @@ public class GridLoggerProxy implements IgniteLogger, LifecycleAware, Externaliz * No-arg constructor is required by externalization. */ public GridLoggerProxy() { - // No-op. + metrics = new LogMetrics(); } /** @@ -81,12 +92,30 @@ public GridLoggerProxy() { * @param id8 Node ID. */ public GridLoggerProxy(IgniteLogger impl, @Nullable Object ctgr, @Nullable String igniteInstanceName, String id8) { + this(impl, ctgr, igniteInstanceName, id8, new LogMetrics()); + } + + /** + * @param impl Logger implementation to proxy to. + * @param ctgr Optional logger category. + * @param igniteInstanceName Ignite instance name (can be {@code null} for default grid). + * @param id8 Node ID. + * @param metrics Shared log message metrics. + */ + private GridLoggerProxy( + IgniteLogger impl, + @Nullable Object ctgr, + @Nullable String igniteInstanceName, + String id8, + LogMetrics metrics + ) { assert impl != null; this.impl = impl; this.ctgr = ctgr; this.igniteInstanceName = igniteInstanceName; this.id8 = id8; + this.metrics = metrics; } /** {@inheritDoc} */ @@ -104,7 +133,7 @@ public GridLoggerProxy(IgniteLogger impl, @Nullable Object ctgr, @Nullable Strin @Override public IgniteLogger getLogger(Object ctgr) { assert ctgr != null; - return new GridLoggerProxy(impl.getLogger(ctgr), ctgr, igniteInstanceName, id8); + return new GridLoggerProxy(impl.getLogger(ctgr), ctgr, igniteInstanceName, id8, metrics); } /** {@inheritDoc} */ @@ -114,64 +143,103 @@ public GridLoggerProxy(IgniteLogger impl, @Nullable Object ctgr, @Nullable Strin /** {@inheritDoc} */ @Override public void trace(String msg) { + if (impl.isTraceEnabled()) + metrics.trace.increment(); + impl.trace(enrich(msg)); } /** {@inheritDoc} */ @Override public void trace(@Nullable String marker, String msg) { + if (impl.isTraceEnabled()) + metrics.trace.increment(); + impl.trace(marker, enrich(msg)); } /** {@inheritDoc} */ @Override public void debug(String msg) { + if (impl.isDebugEnabled()) + metrics.debug.increment(); + impl.debug(enrich(msg)); } /** {@inheritDoc} */ @Override public void debug(@Nullable String marker, String msg) { + if (impl.isDebugEnabled()) + metrics.debug.increment(); + impl.debug(marker, enrich(msg)); } /** {@inheritDoc} */ @Override public void info(String msg) { + if (impl.isInfoEnabled()) + metrics.info.increment(); + impl.info(enrich(msg)); } /** {@inheritDoc} */ @Override public void info(@Nullable String marker, String msg) { + if (impl.isInfoEnabled()) + metrics.info.increment(); + impl.info(marker, enrich(msg)); } /** {@inheritDoc} */ @Override public void warning(String msg) { + metrics.warning.increment(); + impl.warning(enrich(msg)); } /** {@inheritDoc} */ @Override public void warning(String msg, Throwable e) { + metrics.warning.increment(); + impl.warning(enrich(msg), e); } /** {@inheritDoc} */ @Override public void warning(@Nullable String marker, String msg, @Nullable Throwable e) { + metrics.warning.increment(); + impl.warning(marker, enrich(msg), e); } /** {@inheritDoc} */ @Override public void error(String msg) { + metrics.error.increment(); + impl.error(enrich(msg)); } /** {@inheritDoc} */ @Override public void error(String msg, Throwable e) { + metrics.error.increment(); + impl.error(enrich(msg), e); } /** {@inheritDoc} */ @Override public void error(@Nullable String marker, String msg, @Nullable Throwable e) { + metrics.error.increment(); + impl.error(marker, enrich(msg), e); } + /** + * Registers log metrics with the metric manager of this logger's node or application. + * + * @param metricMgr Metric manager. + */ + public void registerMetrics(GridMetricManager metricMgr) { + metrics.register(metricMgr.registry(LOG_COUNT_METRICS)); + } + /** {@inheritDoc} */ @Override public boolean isTraceEnabled() { return impl.isTraceEnabled(); @@ -210,7 +278,9 @@ public String getLoggerInfo() { * @return Enriched message or the original one. */ private String enrich(@Nullable String m) { - return logIgniteInstanceName && m != null ? "<" + igniteInstanceName + '-' + id8 + "> " + m : m; + return logIgniteInstanceName && m != null + ? "<" + igniteInstanceName + (id8 == null ? "" : '-' + id8) + "> " + m + : m; } /** {@inheritDoc} */ @@ -255,4 +325,42 @@ protected Object readResolve() throws ObjectStreamException { @Override public String toString() { return S.toString(GridLoggerProxy.class, this); } + + /** Shared log message metrics for all logger categories of a node. */ + private static class LogMetrics { + /** Trace messages count. */ + private final LongAdderMetric trace = metric("trace", "Total number of TRACE log messages."); + + /** Debug messages count. */ + private final LongAdderMetric debug = metric("debug", "Total number of DEBUG log messages."); + + /** Info messages count. */ + private final LongAdderMetric info = metric("info", "Total number of INFO log messages."); + + /** Warning messages count. */ + private final LongAdderMetric warning = metric("warning", "Total number of WARN log messages."); + + /** Error messages count. */ + private final LongAdderMetric error = metric("error", "Total number of ERROR log messages."); + + /** + * @param name Metric name. + * @param desc Metric description. + * @return Metric. + */ + private static LongAdderMetric metric(String name, String desc) { + return new LongAdderMetric(metricName(LOG_COUNT_METRICS, name), desc); + } + + /** + * @param mreg Metrics registry. + */ + private void register(MetricRegistryImpl mreg) { + mreg.register(trace); + mreg.register(debug); + mreg.register(info); + mreg.register(warning); + mreg.register(error); + } + } } 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 5d11403186f4e..f8189acad35f1 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 @@ -1204,6 +1204,9 @@ public void start( ctx.pools().registerMetrics(); + if (ctx.metric().enabled()) + log.registerMetrics(ctx.metric()); + registerMetrics(); registerConfigurationSystemView(); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cdc/CdcMain.java b/modules/core/src/main/java/org/apache/ignite/internal/cdc/CdcMain.java index b874a1c966538..a5e145764eb3e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/cdc/CdcMain.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/cdc/CdcMain.java @@ -274,7 +274,12 @@ public CdcMain( try { U.initWorkDir(igniteCfg); - log = U.initLogger(igniteCfg, "ignite-cdc"); + log = new GridLoggerProxy( + U.initLogger(igniteCfg, "ignite-cdc"), + null, + cdcInstanceName(igniteCfg.getIgniteInstanceName()), + igniteCfg.getNodeId() == null ? null : U.id8(igniteCfg.getNodeId()) + ); } catch (IgniteCheckedException e) { throw new IgniteException(e); @@ -402,6 +407,9 @@ private void startStandaloneKernal() throws IgniteCheckedException { metricSpi.onContextInitialized(new StandaloneSpiContext()); } + if (kctx.metric().enabled()) + ((GridLoggerProxy)log).registerMetrics(kctx.metric()); + mreg = kctx.metric().registry("cdc"); } diff --git a/modules/core/src/test/java/org/apache/ignite/cdc/CdcSelfTest.java b/modules/core/src/test/java/org/apache/ignite/cdc/CdcSelfTest.java index 1c2132c497bb9..61312059afae9 100644 --- a/modules/core/src/test/java/org/apache/ignite/cdc/CdcSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/cdc/CdcSelfTest.java @@ -36,9 +36,11 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Supplier; import java.util.stream.Collectors; +import javax.management.DynamicMBean; import org.apache.ignite.Ignite; import org.apache.ignite.IgniteCache; import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.IgniteLogger; import org.apache.ignite.binary.BinaryType; import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.DataRegionConfiguration; @@ -58,6 +60,7 @@ import org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager; import org.apache.ignite.internal.processors.cache.persistence.wal.reader.IgniteWalIteratorFactory; import org.apache.ignite.internal.processors.cache.persistence.wal.reader.IgniteWalIteratorFactory.IteratorParametersBuilder; +import org.apache.ignite.internal.processors.cache.persistence.wal.reader.StandaloneGridKernalContext; import org.apache.ignite.internal.processors.configuration.distributed.DistributedChangeableProperty; import org.apache.ignite.internal.processors.platform.cache.expiry.PlatformExpiryPolicy; import org.apache.ignite.internal.util.lang.GridAbsPredicate; @@ -68,6 +71,7 @@ import org.apache.ignite.internal.visor.VisorTaskArgument; import org.apache.ignite.metric.MetricRegistry; import org.apache.ignite.spi.metric.HistogramMetric; +import org.apache.ignite.spi.metric.LongMetric; import org.apache.ignite.testframework.junits.WithSystemProperty; import org.junit.Test; import org.junit.runner.RunWith; @@ -83,6 +87,7 @@ import static org.apache.ignite.configuration.DataStorageConfiguration.DFLT_PAGE_SIZE; import static org.apache.ignite.configuration.DataStorageConfiguration.DFLT_WAL_ARCHIVE_PATH; import static org.apache.ignite.internal.cdc.CdcMain.SEGMENT_CONSUMING_TIME; +import static org.apache.ignite.internal.cdc.CdcMain.cdcInstanceName; import static org.apache.ignite.internal.processors.cache.GridCacheUtils.cacheId; import static org.apache.ignite.testframework.GridTestUtils.assertThrows; import static org.apache.ignite.testframework.GridTestUtils.getFieldValue; @@ -172,6 +177,71 @@ public static Collection parameters() { storagePath = ThreadLocalRandom.current().nextBoolean() ? CUSTOM_CACHE_DATA_ROOT : null; } + /** CDC exports its own log counters independently from the source node in the same JVM. */ + @Test + public void testLogCountMetrics() throws Exception { + IgniteConfiguration cfg = getConfiguration("ignite-0"); + + IgniteEx ignite = startGrid(cfg); + + ignite.cluster().state(ACTIVE); + + CountDownLatch consumerStarted = new CountDownLatch(1); + + CdcMain cdc = createCdc(new UserCdcConsumer() { + @Override public void start(MetricRegistry mreg) { + super.start(mreg); + + consumerStarted.countDown(); + } + }, cfg); + + IgniteInternalFuture fut = runCdcAsync(cdc, consumerStarted); + + try { + assertTrue(consumerStarted.await(getTestTimeout(), MILLISECONDS)); + assertTrue(waitForCondition(() -> Boolean.TRUE.equals(getFieldValue(cdc, "started")) || fut.isDone(), + getTestTimeout())); + assertTrue("CDC failed to start", Boolean.TRUE.equals(getFieldValue(cdc, "started"))); + + DynamicMBean nodeBean = metricRegistry(ignite.name(), "log", "count"); + DynamicMBean cdcBean = metricRegistry(cdcInstanceName(cfg.getIgniteInstanceName()), "log", "count"); + + for (String level : new String[] {"trace", "debug", "info", "warning", "error"}) { + assertTrue(level, nodeBean.getAttribute(level) instanceof Long); + assertTrue(level, cdcBean.getAttribute(level) instanceof Long); + } + + StandaloneGridKernalContext cdcCtx = getFieldValue(cdc, "kctx"); + LongMetric nodeError = ignite.context().metric().registry("log.count").findMetric("error"); + LongMetric cdcError = cdcCtx.metric().registry("log.count").findMetric("error"); + + assertNotSame(nodeError, cdcError); + + long nodeBefore = nodeError.value(); + long cdcBefore = cdcError.value(); + + IgniteLogger cdcLog = getFieldValue(cdc, "log"); + + cdcLog.error("Test CDC log counter"); + + assertEquals(cdcBefore + 1, cdcError.value()); + assertEquals(nodeBefore, nodeError.value()); + assertEquals(cdcError.value(), cdcBean.getAttribute("error")); + + ignite.log().error("Test Ignite log counter"); + + assertEquals(nodeBefore + 1, nodeError.value()); + assertEquals(cdcBefore + 1, cdcError.value()); + assertEquals(nodeError.value(), nodeBean.getAttribute("error")); + } + finally { + cdc.stop(); + + fut.cancel(); + } + } + /** Simplest CDC test. */ @Test public void testReadAllKeysCommitAll() throws Exception { diff --git a/modules/core/src/test/java/org/apache/ignite/internal/GridLoggerProxyMetricsTest.java b/modules/core/src/test/java/org/apache/ignite/internal/GridLoggerProxyMetricsTest.java new file mode 100644 index 0000000000000..dacc3820c4294 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/GridLoggerProxyMetricsTest.java @@ -0,0 +1,173 @@ +/* + * 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; + +import org.apache.ignite.IgniteLogger; +import org.apache.ignite.internal.processors.metric.GridMetricManager; +import org.apache.ignite.internal.processors.metric.MetricRegistryImpl; +import org.apache.ignite.spi.metric.LongMetric; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +/** Tests {@link GridLoggerProxy} metrics. */ +public class GridLoggerProxyMetricsTest { + /** */ + @Test + public void testLogMessagesMetrics() { + GridLoggerProxy log = logger(true); + + log.trace("trace"); + log.trace("marker", "trace"); + log.debug("debug"); + log.debug("marker", "debug"); + log.info("info"); + log.info("marker", "info"); + log.getLogger(getClass()).info("info from category logger"); + log.warning("warning"); + log.warning("warning", new Exception()); + log.warning("marker", "warning", null); + log.error("error"); + log.error("error", new Exception()); + log.error("marker", "error", null); + + MetricRegistryImpl mreg = new MetricRegistryImpl(GridLoggerProxy.LOG_COUNT_METRICS, null, null, null, null); + + log.registerMetrics(metricManager(mreg)); + + assertEquals(2, metricValue(mreg, "trace")); + assertEquals(2, metricValue(mreg, "debug")); + assertEquals(3, metricValue(mreg, "info")); + assertEquals(3, metricValue(mreg, "warning")); + assertEquals(3, metricValue(mreg, "error")); + } + + /** */ + @Test + public void testDisabledLevelsAreNotCounted() { + GridLoggerProxy log = logger(false); + + log.trace("trace"); + log.trace("marker", "trace"); + log.debug("debug"); + log.debug("marker", "debug"); + log.info("info"); + log.info("marker", "info"); + log.warning("warning"); + log.error("error"); + + MetricRegistryImpl mreg = new MetricRegistryImpl(GridLoggerProxy.LOG_COUNT_METRICS, null, null, null, null); + + log.registerMetrics(metricManager(mreg)); + + assertEquals(0, metricValue(mreg, "trace")); + assertEquals(0, metricValue(mreg, "debug")); + assertEquals(0, metricValue(mreg, "info")); + assertEquals(1, metricValue(mreg, "warning")); + assertEquals(1, metricValue(mreg, "error")); + } + + /** Messages counted before registration remain visible and updates continue after registration. */ + @Test + public void testUpdatesAfterRegistration() { + GridLoggerProxy log = logger(true); + + log.info("before registration"); + + MetricRegistryImpl mreg = new MetricRegistryImpl(GridLoggerProxy.LOG_COUNT_METRICS, null, null, null, null); + + log.registerMetrics(metricManager(mreg)); + + LongMetric info = mreg.findMetric("info"); + + assertEquals(1, info.value()); + + log.info("after registration"); + + assertEquals(2, info.value()); + } + + /** Categories share their root's counters, while independent roots have separate counters. */ + @Test + public void testSharedCategoriesAndIndependentRoots() { + GridLoggerProxy first = logger(true); + GridLoggerProxy second = logger(true); + + IgniteLogger category = first.getLogger("first category"); + IgniteLogger nestedCategory = category.getLogger("nested category"); + IgniteLogger anotherCategory = first.getLogger("another category"); + + MetricRegistryImpl firstReg = new MetricRegistryImpl(GridLoggerProxy.LOG_COUNT_METRICS, null, null, null, null); + MetricRegistryImpl secondReg = new MetricRegistryImpl(GridLoggerProxy.LOG_COUNT_METRICS, null, null, null, null); + + ((GridLoggerProxy)nestedCategory).registerMetrics(metricManager(firstReg)); + second.registerMetrics(metricManager(secondReg)); + + first.info("root"); + category.info("category"); + nestedCategory.info("nested category"); + anotherCategory.info("another category"); + + assertEquals(4, metricValue(firstReg, "info")); + assertEquals(0, metricValue(secondReg, "info")); + + second.info("independent root"); + + assertEquals(4, metricValue(firstReg, "info")); + assertEquals(1, metricValue(secondReg, "info")); + } + + /** + * @param enabled Whether TRACE, DEBUG and INFO are enabled. + * @return Logger with a backend whose levels are controlled by the test. + */ + private GridLoggerProxy logger(boolean enabled) { + IgniteLogger impl = mock(IgniteLogger.class); + + when(impl.isTraceEnabled()).thenReturn(enabled); + when(impl.isDebugEnabled()).thenReturn(enabled); + when(impl.isInfoEnabled()).thenReturn(enabled); + when(impl.getLogger(any())).thenReturn(impl); + + return new GridLoggerProxy(impl, null, null, "node-id"); + } + + /** + * @param mreg Metrics registry. + * @return Metric manager returning the registry for log counters. + */ + private GridMetricManager metricManager(MetricRegistryImpl mreg) { + GridMetricManager metricMgr = mock(GridMetricManager.class); + + when(metricMgr.registry(GridLoggerProxy.LOG_COUNT_METRICS)).thenReturn(mreg); + + return metricMgr; + } + + /** + * @param mreg Metrics registry. + * @param name Metric name. + * @return Metric value. + */ + private long metricValue(MetricRegistryImpl mreg, String name) { + return mreg.findMetric(name).value(); + } +} diff --git a/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java b/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java index 36b457963d5dc..fad302b7cc730 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java @@ -207,6 +207,24 @@ public void testJmxMetricsExporterIsDisabled() throws Exception { stream(cfg.getMetricExporterSpi()).noneMatch(spi -> spi instanceof JmxMetricExporterSpi)); } + /** Log counters are registered at node startup and exported for all logger categories. */ + @Test + public void testLogCountMetrics() throws Exception { + IgniteEx ignite = startGrid(0); + + DynamicMBean bean = metricRegistry(ignite.name(), "log", "count"); + + for (String level : new String[] {"trace", "debug", "info", "warning", "error"}) + assertTrue(level, bean.getAttribute(level) instanceof Long); + + long before = (Long)bean.getAttribute("error"); + + ignite.log().error("Test log count from node logger"); + ignite.log().getLogger("log-count-test").error("Test log count from category logger"); + + assertTrue((Long)bean.getAttribute("error") >= before + 2); + } + /** */ @Test public void testSysJmxMetrics() throws Exception { diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteBasicTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteBasicTestSuite.java index 7273f0d23b243..728ada1c57202 100644 --- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteBasicTestSuite.java +++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteBasicTestSuite.java @@ -23,6 +23,7 @@ import org.apache.ignite.internal.GridFailFastNodeFailureDetectionSelfTest; import org.apache.ignite.internal.GridLifecycleAwareSelfTest; import org.apache.ignite.internal.GridLifecycleBeanSelfTest; +import org.apache.ignite.internal.GridLoggerProxyMetricsTest; import org.apache.ignite.internal.GridMBeansTest; import org.apache.ignite.internal.GridMbeansMiscTest; import org.apache.ignite.internal.GridNodeMetricsLogSelfTest; @@ -135,6 +136,7 @@ GridEventConsumeSelfTest.class, GridSuppressedExceptionSelfTest.class, GridLifecycleAwareSelfTest.class, + GridLoggerProxyMetricsTest.class, GridMessageListenSelfTest.class, GridFailFastNodeFailureDetectionSelfTest.class, IgniteSlowClientDetectionSelfTest.class,