taskId, Class exceptionClassName) {
+ String tid = null;
+ if (taskId.isPresent()) {
+ tid = taskId.get();
+ } else {
+ tid = NA;
+ }
+ return get(nodeName, tid, exceptionClassName.getName());
+ }
+
+ public void setNodeName(String nodeName) {
+ this.nodeName = nodeName;
+ }
+
+}
diff --git a/src/main/java/com/harman/ignite/utils/metrics/IgniteGuage.java b/src/main/java/com/harman/ignite/utils/metrics/IgniteGuage.java
new file mode 100644
index 0000000..cb3b1b6
--- /dev/null
+++ b/src/main/java/com/harman/ignite/utils/metrics/IgniteGuage.java
@@ -0,0 +1,104 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import com.harman.ignite.utils.logger.IgniteLogger;
+import com.harman.ignite.utils.logger.IgniteLoggerFactory;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.Gauge;
+
+import java.util.Objects;
+
+/**
+ * Wrapper around Prometheus Guage.
+ *
+ * @author avadakkootko
+ */
+public abstract class IgniteGuage {
+
+ private static final IgniteLogger LOGGER = IgniteLoggerFactory.getLogger(IgniteGuage.class);
+
+ private Gauge igniteGuageMetric;
+
+ /**
+ * Set the metric's value.
+
+ * @param value The value to set.
+ * @param labelValues Label values to set the value for.
+ */
+ public void set(double value, String... labelValues) {
+ Objects.requireNonNull(igniteGuageMetric, "IgniteGuage is not initialized");
+ synchronized (this.igniteGuageMetric) {
+ igniteGuageMetric.labels(labelValues).set(value);
+ }
+ }
+
+ /**
+ * Get the value of the guage.
+ *
+ * @param labelValues label values
+ * @return The value of the guage.
+ */
+ public double get(String... labelValues) {
+ double value = 0;
+ Objects.requireNonNull(igniteGuageMetric, "IgniteGuage is not initialized");
+ value = igniteGuageMetric.labels(labelValues).get();
+ return value;
+ }
+
+ protected void createGuage(String name, String... labels) {
+ if (null == igniteGuageMetric) {
+ synchronized (this) {
+ igniteGuageMetric = Gauge.build(name, name)
+ .labelNames(labels)
+ .register(CollectorRegistry.defaultRegistry);
+ LOGGER.info("Created ignite guage with name : {} and labels {}", name, labels);
+ }
+ } else {
+ LOGGER.warn("Ignite guage with name : {} and labels {}, already created", name, labels);
+ }
+ }
+
+ // setter and getter for unit tests
+ Gauge getIgniteGuageMetric() {
+ return this.igniteGuageMetric;
+ }
+
+ void setIgniteGuageMetric(Gauge igniteGuageMetric) {
+ this.igniteGuageMetric = igniteGuageMetric;
+ }
+}
diff --git a/src/main/java/com/harman/ignite/utils/metrics/IgniteHealthGuage.java b/src/main/java/com/harman/ignite/utils/metrics/IgniteHealthGuage.java
new file mode 100644
index 0000000..eb82ae6
--- /dev/null
+++ b/src/main/java/com/harman/ignite/utils/metrics/IgniteHealthGuage.java
@@ -0,0 +1,52 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import org.springframework.stereotype.Component;
+
+/**
+ * IgniteHealthGuage will be used by various HealthMonitors for publishing their respective health status to prometheus.
+ *
+ * @author avadakkootko
+ */
+@Component
+public class IgniteHealthGuage extends IgniteGuage {
+
+ public IgniteHealthGuage() {
+ createGuage("service_health_metric", "node", "monitorname");
+ }
+}
diff --git a/src/main/java/com/harman/ignite/utils/metrics/IgniteRocksDBGuage.java b/src/main/java/com/harman/ignite/utils/metrics/IgniteRocksDBGuage.java
new file mode 100644
index 0000000..5d461db
--- /dev/null
+++ b/src/main/java/com/harman/ignite/utils/metrics/IgniteRocksDBGuage.java
@@ -0,0 +1,59 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import com.harman.ignite.utils.logger.IgniteLogger;
+import com.harman.ignite.utils.logger.IgniteLoggerFactory;
+import org.springframework.stereotype.Component;
+
+/**
+ * Creates and registers Guage metric in Prometheus for each one of the property-based metrics in RocksDB.
+ * with labels = serviceName
+ * and metricName(the actual name of the RocksDB metric property)
+ *
+ * @author hbadshah
+ */
+@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
+@Component
+public class IgniteRocksDBGuage extends IgniteGuage {
+ private static final IgniteLogger LOGGER = IgniteLoggerFactory.getLogger(IgniteRocksDBGuage.class);
+
+ public void setup() {
+ createGuage("rocksdb_metric", "metric_name", "svc", "node");
+ LOGGER.debug("rocksdb_metric guage successfully created.");
+ }
+}
diff --git a/src/main/java/com/harman/ignite/utils/metrics/InternalCacheGuage.java b/src/main/java/com/harman/ignite/utils/metrics/InternalCacheGuage.java
new file mode 100644
index 0000000..d1480be
--- /dev/null
+++ b/src/main/java/com/harman/ignite/utils/metrics/InternalCacheGuage.java
@@ -0,0 +1,81 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import com.harman.ignite.utils.logger.IgniteLogger;
+import com.harman.ignite.utils.logger.IgniteLoggerFactory;
+import jakarta.annotation.PostConstruct;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+
+/**
+ * Guage for internal cache(s) metric.
+ *
+ * @author hbadshah
+ */
+@Component
+public class InternalCacheGuage extends IgniteGuage {
+
+ private static final IgniteLogger LOGGER = IgniteLoggerFactory.getLogger(InternalCacheGuage.class);
+
+ @Value("${internal.metrics.enabled:false}")
+ private boolean internalMetricsEnabled;
+
+ @Value("${metrics.prometheus.enabled:true}")
+ private boolean prometheusEnabled;
+
+ /**
+ * Setup the guage metric for internal cache.
+ */
+ @PostConstruct
+ public void setup() {
+ if (prometheusEnabled && internalMetricsEnabled) {
+ createGuage("internal_cache_size_metric", "cache_type", "svc", "node", "task_id");
+ LOGGER.info("Guage metric for internal cache created.");
+ }
+ }
+
+ @Override
+ public void set(double value, String... labels) {
+ if (prometheusEnabled && internalMetricsEnabled) {
+ super.set(value, labels);
+ LOGGER.debug("Published metrics for labels: {} with value: {}", Arrays.asList(labels), value);
+ }
+ }
+}
diff --git a/src/main/java/com/harman/ignite/utils/test/NightlyBuildTestCase.java b/src/main/java/com/harman/ignite/utils/test/NightlyBuildTestCase.java
new file mode 100644
index 0000000..3af114c
--- /dev/null
+++ b/src/main/java/com/harman/ignite/utils/test/NightlyBuildTestCase.java
@@ -0,0 +1,54 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.test;
+
+/**
+ * Marker interface to tag a JUnit4 test case to run for nightly build.
+ * Typically, a long-running test case is tagged for nightly build process.
+ * This interface is specified in Maven pom.xml's <excludeGroups/> XML tag to exclude the test cases.
+ * Usage: Tag a test method or class,
+ *
+ * - @org.junit.Test @org.junit.experimental.categories.Category(NightlyBuildTestCase.class)
+ * public void testFoo(){...}
+ * - @org.junit.experimental.categories.Category(NightlyBuildTestCase.class)
+ * public class Foo{...}
+ *
+ *
+ * @author KJalawadi
+ */
+public interface NightlyBuildTestCase {
+}
diff --git a/src/test/java/com/harman/ignite/diagnostic/DiagnosticResultTest.java b/src/test/java/com/harman/ignite/diagnostic/DiagnosticResultTest.java
new file mode 100644
index 0000000..90cc8ab
--- /dev/null
+++ b/src/test/java/com/harman/ignite/diagnostic/DiagnosticResultTest.java
@@ -0,0 +1,55 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.diagnostic;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test class for DiagnosticResult.
+ *
+ * @see DiagnosticResult
+ */
+public class DiagnosticResultTest {
+ private DiagnosticResult res;
+
+ @Test
+ public void testPassAndFail() {
+ Assert.assertEquals(1.0, DiagnosticResult.PASS.getValue(), 0);
+ Assert.assertEquals(0.0, DiagnosticResult.FAIL.getValue(), 0);
+ }
+}
diff --git a/src/test/java/com/harman/ignite/diagnostic/DiagnosticUnitTest.java b/src/test/java/com/harman/ignite/diagnostic/DiagnosticUnitTest.java
new file mode 100644
index 0000000..38eb671
--- /dev/null
+++ b/src/test/java/com/harman/ignite/diagnostic/DiagnosticUnitTest.java
@@ -0,0 +1,185 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.diagnostic;
+
+import com.harman.ignite.utils.logger.IgniteLogger;
+import com.harman.ignite.utils.logger.IgniteLoggerFactory;
+import com.harman.ignite.utils.metrics.IgniteDiagnosticGuage;
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.CollectorRegistry;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+
+/**
+ * Test class for DiagnosticService.
+ *
+ * @see DiagnosticService
+ */
+public class DiagnosticUnitTest {
+ private static final IgniteLogger LOGGER = IgniteLoggerFactory.getLogger(DiagnosticUnitTest.class);
+ @Rule
+ public MockitoRule mockitoRule = MockitoJUnit.rule();
+
+ @InjectMocks
+ private DiagnosticService diagnosticService = new DiagnosticService();
+
+ @Mock
+ private IgniteDiagnosticGuage diagnosticGuage;
+
+ /**
+ * Setup the test.
+ */
+ @Before
+ public void setUp() {
+ clearMetrics();
+ MockitoAnnotations.initMocks(this);
+ diagnosticService.setServiceDiagnosticGuage(diagnosticGuage);
+ diagnosticService.setNodeName("localhost");
+
+ }
+
+ /**
+ * If two DiagnosticReporters have same name it should throw runtime exception.
+ */
+ @Test(expected = RuntimeException.class)
+ public void testInitTwoReportersWithSameName() {
+ final List reporters = new ArrayList<>();
+ TestDiagnosticReporter reporter1 = new TestDiagnosticReporter();
+ reporter1.setEnabled(true);
+ reporter1.setMetricName("Metric1");
+ reporter1.setReporterName("Reporter1");
+ reporters.add(reporter1);
+
+ TestDiagnosticReporter reporter2 = new TestDiagnosticReporter();
+ reporter2.setEnabled(true);
+ reporter2.setMetricName("Metric1");
+ reporter2.setReporterName("Reporter2");
+ reporters.add(reporter2);
+
+ diagnosticService.setReporters(reporters);
+ diagnosticService.getEnabledReporters();
+ }
+
+ /**
+ * If a DiagnosticReporter is disabled it should not be added in the list of DiagnosticReporters.
+ */
+ @Test
+ public void testInitWithDisabledReporter() {
+ final List reporters = new ArrayList<>();
+ TestDiagnosticReporter reporter1 = new TestDiagnosticReporter();
+ reporter1.setEnabled(true);
+ reporter1.setMetricName("Metric1");
+ reporter1.setReporterName("Reporter1");
+ reporters.add(reporter1);
+
+ TestDiagnosticReporter reporter2 = new TestDiagnosticReporter();
+ reporter2.setEnabled(false);
+ reporter2.setMetricName("Metric1");
+ reporter2.setReporterName("Reporter2");
+ reporters.add(reporter2);
+
+ diagnosticService.setReporters(reporters);
+
+ List enabledReporters = diagnosticService.getEnabledReporters();
+ Assert.assertEquals(1, enabledReporters.size());
+ Assert.assertEquals("Metric1", enabledReporters.get(0).getDiagnosticMetricName());
+ Assert.assertEquals("Reporter1", enabledReporters.get(0).getDiagnosticReporterName());
+ }
+
+ @Test
+ public void testMetricPublishing() {
+ final List reporters = new ArrayList<>();
+ TestDiagnosticReporter reporter1 = new TestDiagnosticReporter();
+ reporter1.setEnabled(true);
+ reporter1.setMetricName("Metric1");
+ reporter1.setReporterName("Reporter1");
+ DiagnosticData data = new DiagnosticData();
+ data.put("Metric1Key1", DiagnosticResult.FAIL);
+ data.put("Metric1Key2", DiagnosticResult.PASS);
+ data.put("Metric1Key3", DiagnosticResult.FAIL);
+ reporter1.setData(data);
+ reporters.add(reporter1);
+
+ TestDiagnosticReporter reporter2 = new TestDiagnosticReporter();
+ reporter2.setEnabled(true);
+ reporter2.setMetricName("Metric2");
+ reporter2.setReporterName("Reporter2");
+ DiagnosticData data2 = new DiagnosticData();
+ data2.put("Metric2Key1", DiagnosticResult.PASS);
+ reporter2.setData(data2);
+ reporters.add(reporter2);
+
+ diagnosticService.setReporters(reporters);
+ diagnosticService.triggerDiagnosis();
+
+ Mockito.verify(diagnosticGuage, Mockito.times(1))
+ .set(DiagnosticResult.FAIL.getValue(), "localhost", "Metric1", "Metric1Key1");
+ Mockito.verify(diagnosticGuage, Mockito.times(1))
+ .set(DiagnosticResult.PASS.getValue(), "localhost", "Metric1", "Metric1Key2");
+ Mockito.verify(diagnosticGuage, Mockito.times(1))
+ .set(DiagnosticResult.FAIL.getValue(), "localhost", "Metric1", "Metric1Key3");
+ Mockito.verify(diagnosticGuage, Mockito.times(1))
+ .set(DiagnosticResult.PASS.getValue(), "localhost", "Metric2", "Metric2Key1");
+
+ }
+
+ /**
+ * Clear all the metrics.
+ */
+ public void clearMetrics() {
+ Enumeration mfsEnumerator = CollectorRegistry.defaultRegistry.metricFamilySamples();
+ while (mfsEnumerator.hasMoreElements()) {
+ MetricFamilySamples mfs = mfsEnumerator.nextElement();
+ if (mfs.samples != null) {
+ mfs.samples.clear();
+ }
+ }
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/diagnostic/PropertyDiagnosticReporterTest.java b/src/test/java/com/harman/ignite/diagnostic/PropertyDiagnosticReporterTest.java
new file mode 100644
index 0000000..be8f138
--- /dev/null
+++ b/src/test/java/com/harman/ignite/diagnostic/PropertyDiagnosticReporterTest.java
@@ -0,0 +1,107 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.diagnostic;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+/**
+ * Test class for DiagnosticReporter.
+ *
+ * @see DiagnosticReporter
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { TestDiagnosticReporterConfig.class })
+@TestPropertySource(
+ locations = {"classpath:property-diagnostic-test.properties", "classpath:property-diagnostic-test-2.properties"}
+)
+public class PropertyDiagnosticReporterTest {
+ @Autowired
+ @Qualifier("propertyDiagnostic")
+ DiagnosticReporter propertyDiagnosticReporterImpl;
+
+ @Before
+ public void setUp() {
+
+ }
+
+ @Test
+ public void testDiagnosticReporterName() {
+ Assert.assertEquals("DIAGNOSTIC_PROPERTY_REPORTER", propertyDiagnosticReporterImpl.getDiagnosticReporterName());
+ }
+
+ @Test
+ public void testDiagnosticMetricName() {
+ Assert.assertEquals("DIAGNOSTIC_PROPERTY_METRIC", propertyDiagnosticReporterImpl.getDiagnosticMetricName());
+ }
+
+ @Test
+ public void isDiagnosticReporterEnabled() {
+ Assert.assertTrue(propertyDiagnosticReporterImpl.isDiagnosticReporterEnabled());
+
+ }
+
+ @Test
+ public void testPropertyDiagnosticReporter() {
+ DiagnosticData diagnosticData = propertyDiagnosticReporterImpl.getDiagnosticData();
+
+ diagnosticData.forEach((key, value) -> System.out.println("property: " + key + "value: " + value));
+
+ Assert.assertEquals(DiagnosticResult.FAIL, diagnosticData.get("mongodb.hosts"));
+ Assert.assertEquals(DiagnosticResult.FAIL, diagnosticData.get("mongodb.port"));
+ Assert.assertEquals(DiagnosticResult.FAIL, diagnosticData.get("mongodb.username"));
+ Assert.assertEquals(DiagnosticResult.FAIL, diagnosticData.get("mongodb.hosts"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.pool.max.size"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.max.wait.time.ms"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.socket.timeout.ms"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.max.connections.per.host"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.block.threads.allowed.multiplier"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.read.preference"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("morphia.map.packages"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("mongodb.socket.timeout.ms"));
+ Assert.assertEquals(DiagnosticResult.PASS, diagnosticData.get("morphia.converters.fqn"));
+ Assert.assertEquals(DiagnosticResult.FAIL, diagnosticData.get("vault.secret.folder"));
+ Assert.assertEquals(DiagnosticResult.FAIL, diagnosticData.get("vault.environment"));
+ }
+}
diff --git a/src/test/java/com/harman/ignite/diagnostic/TestDiagnosticReporter.java b/src/test/java/com/harman/ignite/diagnostic/TestDiagnosticReporter.java
new file mode 100644
index 0000000..52a9d7c
--- /dev/null
+++ b/src/test/java/com/harman/ignite/diagnostic/TestDiagnosticReporter.java
@@ -0,0 +1,85 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.diagnostic;
+
+/**
+ * Test POJO for DiagnosticReporter.
+ */
+public class TestDiagnosticReporter implements DiagnosticReporter {
+
+ private boolean enabled;
+ private String reporterName = "TestDiagnosticReporter";
+ private String metricName = "TestDiagnosticReporterGuage";
+ private DiagnosticData data = new DiagnosticData();
+
+ @Override
+ public boolean isDiagnosticReporterEnabled() {
+ return enabled;
+ }
+
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ @Override
+ public String getDiagnosticReporterName() {
+ return reporterName;
+ }
+
+ @Override
+ public String getDiagnosticMetricName() {
+ return metricName;
+ }
+
+ public void setReporterName(String reporterName) {
+ this.reporterName = reporterName;
+ }
+
+ public void setMetricName(String metricName) {
+ this.metricName = metricName;
+ }
+
+ @Override
+ public DiagnosticData getDiagnosticData() {
+ return data;
+ }
+
+ public void setData(DiagnosticData data) {
+ this.data = data;
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/diagnostic/TestDiagnosticReporterConfig.java b/src/test/java/com/harman/ignite/diagnostic/TestDiagnosticReporterConfig.java
new file mode 100644
index 0000000..492ed50
--- /dev/null
+++ b/src/test/java/com/harman/ignite/diagnostic/TestDiagnosticReporterConfig.java
@@ -0,0 +1,56 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.diagnostic;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Test configuration for initializing a diagnostic reporter and testing it as PropertyDiagnosticReporterTest.
+ *
+ * @see PropertyDiagnosticReporterTest
+ */
+@Configuration
+@ComponentScan(basePackages = { "com.harman.ignite" })
+public class TestDiagnosticReporterConfig {
+
+ @Bean
+ public PropertyDiagnosticReporterTest testPropertyDiagnosticReporter() {
+ return new PropertyDiagnosticReporterTest();
+ }
+}
diff --git a/src/test/java/com/harman/ignite/healthcheck/HealthServiceIntegrationTestCase.java b/src/test/java/com/harman/ignite/healthcheck/HealthServiceIntegrationTestCase.java
new file mode 100644
index 0000000..ea123cd
--- /dev/null
+++ b/src/test/java/com/harman/ignite/healthcheck/HealthServiceIntegrationTestCase.java
@@ -0,0 +1,161 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.healthcheck;
+
+import com.harman.ignite.utils.logger.IgniteLogger;
+import com.harman.ignite.utils.logger.IgniteLoggerFactory;
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.Collector.MetricFamilySamples.Sample;
+import io.prometheus.client.CollectorRegistry;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.util.Enumeration;
+import java.util.List;
+
+/**
+ * Integration test for HealthService.
+ *
+ * @see HealthService
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { TestHealthServiceConfig.class })
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class HealthServiceIntegrationTestCase {
+
+ static final double HEALTHY = 0.0;
+ static final double UNHEALTHY = 1.0;
+ static final int TWO = 2;
+ static final String SERVICE_HEALTH = "SERVICE_HEALTH";
+ private static final IgniteLogger LOGGER = IgniteLoggerFactory.getLogger(HealthServiceIntegrationTestCase.class);
+ @Autowired
+ private HealthService healthService;
+
+ @Before
+ public void setup() {
+ clearMetrics();
+ }
+
+ /**
+ * Post constructor should have autowired the health monitors and not started the executor.
+ */
+ @Test
+ public void testInit() {
+ List monitors = healthService.getHealthMonitors();
+ // Although 3 monitors are present in Configuration class one is
+ // disabled hence only 2 monitors should be present
+ Assert.assertEquals(TWO, monitors.size());
+ }
+
+ @Test
+ public void testNeedsRestartWithHealthyMonitor() throws InterruptedException {
+ TestHealthMonitor overrideMonitor = new TestHealthMonitor();
+ overrideMonitor.setEnabled(true);
+ overrideMonitor.setHealthy(true);
+ overrideMonitor.setNeedsRestartOnFailure(true);
+
+ List monitors = healthService.getHealthMonitors();
+
+ monitors.clear();
+ monitors.add(overrideMonitor);
+
+ healthService.setHealthMonitors(monitors);
+
+ Assert.assertFalse(healthService.needsRestart());
+
+ Enumeration allSamples = CollectorRegistry.defaultRegistry.metricFamilySamples();
+
+ while (allSamples.hasMoreElements()) {
+ MetricFamilySamples samples = allSamples.nextElement();
+ LOGGER.info("Metric name {}", samples.name);
+
+ for (Sample sample : samples.samples) {
+ Assert.assertEquals(HEALTHY, sample.value, 0.0D);
+ }
+ }
+
+ }
+
+ @Test
+ public void testNeedsRestartWithUnHealthyMonitor() throws InterruptedException {
+ TestHealthMonitor overrideMonitor = new TestHealthMonitor();
+ overrideMonitor.setEnabled(true);
+ overrideMonitor.setHealthy(false);
+ overrideMonitor.setNeedsRestartOnFailure(true);
+
+ List monitors = healthService.getHealthMonitors();
+
+ monitors.clear();
+ monitors.add(overrideMonitor);
+
+ healthService.setHealthMonitors(monitors);
+
+ Assert.assertTrue(healthService.needsRestart());
+
+ Enumeration allSamples = CollectorRegistry.defaultRegistry.metricFamilySamples();
+
+ while (allSamples.hasMoreElements()) {
+ MetricFamilySamples samples = allSamples.nextElement();
+ LOGGER.info("Metric name {}", samples.name);
+
+ for (Sample sample : samples.samples) {
+ Assert.assertEquals(UNHEALTHY, sample.value, 1.0D);
+ }
+ }
+ }
+
+ /**
+ * Clear all the metrics.
+ */
+ public void clearMetrics() {
+ Enumeration mfsEnumerator = CollectorRegistry.defaultRegistry.metricFamilySamples();
+ while (mfsEnumerator.hasMoreElements()) {
+ MetricFamilySamples mfs = mfsEnumerator.nextElement();
+ if (mfs.samples != null) {
+ mfs.samples.clear();
+ }
+ }
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/healthcheck/HealthServiceStateTest.java b/src/test/java/com/harman/ignite/healthcheck/HealthServiceStateTest.java
new file mode 100644
index 0000000..6b0a6cf
--- /dev/null
+++ b/src/test/java/com/harman/ignite/healthcheck/HealthServiceStateTest.java
@@ -0,0 +1,110 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.healthcheck;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+
+import java.util.ArrayList;
+
+/** Test class for HealthServiceState.
+ *
+ * @see HealthServiceState
+ */
+public class HealthServiceStateTest {
+
+ @InjectMocks
+ private HealthServiceState serviceState;
+
+ private double state;
+ private String message;
+
+ /**
+ * Setup the test.
+ */
+ @Before
+ public void setup() {
+ MockitoAnnotations.initMocks(this);
+ state = 0;
+ message = "Test message";
+ }
+
+ @Test
+ public void testSetState() {
+ serviceState.setState(state);
+ Assert.assertEquals(0, serviceState.getState(), 0);
+ }
+
+ @Test
+ public void testSetMessage() {
+ serviceState.setMessage(message);
+ Assert.assertEquals("Test message", serviceState.getMessage());
+ }
+
+ @Test
+ public void testEquals() {
+ HealthServiceState serviceState1 = new HealthServiceState();
+ serviceState1.setState(1);
+ serviceState1.setMessage("Unhealthy");
+ HealthServiceState serviceState2 = new HealthServiceState();
+ serviceState2.setState(1);
+ serviceState2.setMessage("Unhealthy");
+ Assert.assertEquals(serviceState1, (serviceState2));
+ serviceState1.setState(0);
+ Assert.assertNotEquals(serviceState1, (serviceState2));
+ serviceState2.setMessage("test");
+ Assert.assertNotNull(String.valueOf(serviceState1), (serviceState2));
+ serviceState2.setMessage(null);
+ Assert.assertNotEquals(serviceState1, (serviceState2));
+ Assert.assertNotNull(serviceState1);
+ Assert.assertNotEquals(serviceState1, (new ArrayList()));
+ serviceState1.setMessage(null);
+ serviceState2.setMessage("test");
+ Assert.assertNotEquals(serviceState1, (serviceState2));
+ }
+
+
+ @Test
+ public void testHashCode() {
+ serviceState.setState(0);
+ serviceState.setMessage(message);
+ Assert.assertNotEquals(serviceState.hashCode(), 0);
+ }
+}
diff --git a/src/test/java/com/harman/ignite/healthcheck/HealthServiceUnitTest.java b/src/test/java/com/harman/ignite/healthcheck/HealthServiceUnitTest.java
new file mode 100644
index 0000000..4533603
--- /dev/null
+++ b/src/test/java/com/harman/ignite/healthcheck/HealthServiceUnitTest.java
@@ -0,0 +1,678 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.healthcheck;
+
+import com.harman.ignite.utils.logger.IgniteLogger;
+import com.harman.ignite.utils.logger.IgniteLoggerFactory;
+import com.harman.ignite.utils.metrics.IgniteHealthGuage;
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.CollectorRegistry;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+
+/**
+ * Test class for HealthService.
+ *
+ * @see HealthService
+ */
+public class HealthServiceUnitTest {
+ static final String SERVICE_HEALTH = "SERVICE_HEALTH";
+ static final double HEALTHY = 0;
+ static final double UNHEALTHY = 1;
+ static final int TWO = 2;
+ static final int THREE = 3;
+ static final int FOUR = 4;
+ static final int FIVE = 5;
+ static final int SEVEN = 7;
+ static final int HUNDRED = 100;
+ static final long THOUSAND = 1000L;
+ private static final IgniteLogger LOGGER = IgniteLoggerFactory.getLogger(HealthServiceUnitTest.class);
+ @Rule
+ public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @InjectMocks
+ private HealthService healthService = new HealthService();
+
+ @Mock
+ private IgniteHealthGuage serviceHealthGuage;
+ @Mock
+ private ThreadUtils threadUtils;
+
+ /**
+ * Setup the test.
+ */
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ healthService.setServiceHealthGuage(serviceHealthGuage);
+ healthService.setFailureRetryInterval(HUNDRED);
+ healthService.setFailureRetryThreshold(TWO);
+ healthService.setRetryInterval(HUNDRED);
+ healthService.setNodeName("localhost");
+ }
+
+ /**
+ * HealthMonitor used simple TestHealthMonitor;
+ * Count = 2; Both healthMonitors are enabled; Both healthMonitors are set healthy ; Force
+ * is set to false;
+ * Expecting success.
+ */
+ @Test
+ public void testCheckHealthAndGetFailedMonitorsWithForceFalse() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+ boolean force = false;
+
+ // Validate Failed hms should be 0
+ List failedHms = healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Assert.assertEquals(0, failedHms.size());
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", SERVICE_HEALTH);
+ }
+
+ /**
+ * HealthMonitor used simple TestHealthMonitor;
+ * Count = 2; Both healthMonitors are enabled; Both healthMonitors are set healthy ; Force
+ * is set to false;
+ * Expecting success.
+ */
+ @Test
+ public void testCheckHealthAndGetFailedMonitorsWithForceFalseWithPromethus() {
+ Enumeration allSamples = CollectorRegistry.defaultRegistry.metricFamilySamples();
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+ boolean force = false;
+
+ // Validate Failed hms should be 0
+ List failedHms = healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Assert.assertEquals(0, failedHms.size());
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", SERVICE_HEALTH);
+
+ }
+
+ /**
+ * HealthMonitor used simple TestHealthMonitor;
+ * Count = 2; Both healthMonitors are enabled; HealthMonitor 1 is set healthy ;
+ * HealthMonitor 2 is set to unhealthy ; Force is set to false;
+ * As one health monitor is not healthy we are expecting one failed health monitor
+ * Expecting failure.
+ */
+ @Test
+ public void testCheckHealthAndGetFailedMonitorsWithForceFalseWhenOneMonitorIsUnHealthy() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(false);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+ boolean force = false;
+
+ // Validate Failed hms should be 1
+ List failedHms = healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Assert.assertEquals(1, failedHms.size());
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+ }
+
+ /**
+ * HealthMonitor used simple TestHealthMonitor;
+ * Count = 2; Both healthMonitors are enabled; Both HealthMonitors are set healthy ; Force
+ * is set to true;
+ * As both health monitors are healthy setting force to true or false should not have any impact
+ * Expecting success.
+ */
+ @Test
+ public void testCheckHealthAndGetFailedMonitorsWithForceTrueWhenHealthMonitorsAreHealthy() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+ boolean force = true;
+
+ // Validate Failed hms should be 0
+ List failedHms = healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Assert.assertEquals(0, failedHms.size());
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", SERVICE_HEALTH);
+ }
+
+ /**
+ * Here we are using two types of health monitors TestHealthMonitor and TestHealthMonitorWithForce.
+ * Both healthMonitors are enabled;
+ * Both HealthMonitors are set healthy ; Force is set to true;
+ * As one is unhealthy and force is true we will be retrying.
+ * Expecting success after retrying.
+ */
+ @Test
+ public void testCheckHealthAndGetFailedMonitorsWithForceTrueWhenHealthMonitorsAreUnHealthy() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitorWithForce hm = new TestHealthMonitorWithForce();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+ boolean force = true;
+ healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+
+ healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Mockito.verify(serviceHealthGuage, Mockito.times(TWO))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(TWO))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(TWO))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+
+ healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Mockito.verify(serviceHealthGuage, Mockito.times(THREE))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(THREE))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(THREE))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+
+ healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Mockito.verify(serviceHealthGuage, Mockito.times(FOUR))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(FOUR))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(FOUR))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+
+ healthService.checkHealthAndGetFailedMonitors(force, hms);
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(FIVE))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", SERVICE_HEALTH);
+
+ }
+
+ /**
+ * HealthMonitor used simple TestHealthMonitor;
+ * Count = 2; Both healthMonitors are enabled; HealthMonitor 1 is set healthy ;
+ * HealthMonitor 2 is set to unhealthy ;
+ *
+ * As one health monitor is unhealthy we are expecting failure not have any impact
+ *
+ * Expecting failure.
+ */
+ @Test
+ public void testTriggerInitialCheck() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(false);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+
+ List failedList = healthService.triggerInitialCheck();
+ Assert.assertEquals(1, failedList.size());
+
+ Assert.assertEquals("Metric2", failedList.get(0).metricName());
+ Assert.assertEquals("Monitor2", failedList.get(0).monitorName());
+
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+
+ hms.clear();
+ hm2.setHealthy(true);
+ hms.add(hm2);
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List list = healthService.triggerInitialCheck();
+ Assert.assertEquals(0, list.size());
+ }
+
+ @Test
+ public void testClose() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(false);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ healthService.close();
+
+ Assert.assertFalse(healthService.isStartedExecutor());
+ }
+
+ @Test
+ public void testRegisterCallback() {
+ TestHealthMonitor hm = new TestHealthMonitor();
+ healthService.registerCallBack(hm);
+
+ Assert.assertNotNull(healthService.getCallback());
+ }
+
+ /**
+ * Here we are using two types of health monitors TestHealthMonitor and TestHealthMonitorWithForce.
+ * Both healthMonitors are enabled;
+ * Both HealthMonitors are set healthy ;
+ *
+ * As both are healthy it is a success scenario
+ *
+ * Expecting success.
+ */
+ @Test
+ public void testNeedsRestartFalseScenario() throws InterruptedException {
+ healthService.setFailureRetryThreshold(SEVEN);
+ final List hms = new ArrayList();
+ TestHealthMonitorWithForce hm = new TestHealthMonitorWithForce();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hm.setNeedsRestartOnFailure(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hm2.setNeedsRestartOnFailure(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+
+ boolean restart = healthService.needsRestart();
+ Assert.assertFalse(restart);
+
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", SERVICE_HEALTH);
+
+ }
+
+ /**
+ * Objective is to test the retry threshold of health service.
+ * The method needsRestart will repeat in a loop until the retry threshold is exceeded;
+ * or before that the service becomes healthy. Testing with retry threshold 5.
+ *
+ * The health monitor TestHealthMonitorWithForce will give true after 3 attempts with force true
+ * As both are healthy it is a success scenario.
+ * Hence, for retry threshold > 4 we should get healthy
+ *
+ *
+ * Expecting success after retry.
+ */
+ @Test
+ public void testNeedsRestartFalseScenarioWithRetry() throws InterruptedException {
+ healthService.setFailureRetryThreshold(FIVE);
+ final List hms = new ArrayList<>();
+ TestHealthMonitorWithForce hm = new TestHealthMonitorWithForce();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setNeedsRestartOnFailure(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hm2.setNeedsRestartOnFailure(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+
+ boolean restart = healthService.needsRestart();
+ Assert.assertFalse(restart);
+
+ Mockito.verify(serviceHealthGuage, Mockito.times(FIVE))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(FIVE))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", SERVICE_HEALTH);
+
+ }
+
+ /**
+ * Objective is to test the retry threshold of health service.
+ * The method needsRestart will repeat in a loop until the retry threshold is exceeded;
+ * or before that the service becomes healthy. Testing with retry threshold 5.
+ *
+ * The health monitor TestHealthMonitorWithForce will give true after 3 attempts with force true
+ * As both are healthy it is a success scenario.
+ * Hence, for retry threshold > 4 we should get healthy
+ *
+ *
+ * Expecting failure as retry threshold == 4
+ */
+
+ @Test
+ public void testNeedsRestartTrueScenario() throws InterruptedException {
+ healthService.setFailureRetryThreshold(FOUR);
+ final List hms = new ArrayList<>();
+ TestHealthMonitorWithForce hm = new TestHealthMonitorWithForce();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setNeedsRestartOnFailure(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hm2.setNeedsRestartOnFailure(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+
+ boolean restart = healthService.needsRestart();
+ Assert.assertTrue(restart);
+
+ Mockito.verify(serviceHealthGuage, Mockito.times(FIVE))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(FIVE))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+ }
+
+ /**
+ * If a health monitor needs restart is false.
+ * Even if it is unhealthy the service should return restart false.
+ */
+ @Test
+ public void testNeedsRestartFalseScenarioWithMonitorRestartFalse() throws InterruptedException {
+ healthService.setFailureRetryThreshold(FOUR);
+ final List hms = new ArrayList<>();
+ TestHealthMonitorWithForce hm = new TestHealthMonitorWithForce();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setNeedsRestartOnFailure(false);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hm2.setNeedsRestartOnFailure(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+
+ boolean restart = healthService.needsRestart();
+ Assert.assertFalse(restart);
+
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", "Metric1");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(HEALTHY, "localhost", "Metric2");
+ Mockito.verify(serviceHealthGuage, Mockito.times(1))
+ .set(UNHEALTHY, "localhost", SERVICE_HEALTH);
+ }
+
+ /**
+ * If two health monitors have same name it should throw runtime exception.
+ */
+ @Test(expected = RuntimeException.class)
+ public void testInitTwoMonitorsWithSameName() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric1");
+ hm2.setMonitorName("Monitor2");
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ }
+
+ /**
+ * If a health monitor is disabled, it should not be added in the list of health monitors.
+ */
+ @Test
+ public void testInitWithDisabledMonitor() {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(false);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(1, enabledHms.size());
+ Assert.assertEquals("Metric1", enabledHms.get(0).metricName());
+ Assert.assertEquals("Monitor1", enabledHms.get(0).monitorName());
+ }
+
+ @Test
+ public void testStartHealthServiceExecutor() throws InterruptedException {
+ final List hms = new ArrayList<>();
+ TestHealthMonitor hm = new TestHealthMonitor();
+ hm.setEnabled(true);
+ hm.setMetricName("Metric1");
+ hm.setMonitorName("Monitor1");
+ hm.setHealthy(true);
+ hms.add(hm);
+
+ TestHealthMonitor hm2 = new TestHealthMonitor();
+ hm2.setEnabled(true);
+ hm2.setMetricName("Metric2");
+ hm2.setMonitorName("Monitor2");
+ hm2.setHealthy(true);
+ hms.add(hm2);
+
+ healthService.setHealthMonitors(hms);
+ healthService.init();
+ healthService.startHealthServiceExecutor();
+ LOGGER.info("Started health service");
+ Thread.sleep(THOUSAND);
+ healthService.startHealthServiceExecutor();
+ List enabledHms = healthService.getHealthMonitors();
+ Assert.assertEquals(TWO, enabledHms.size());
+ LOGGER.info("Started again health service");
+ }
+}
diff --git a/src/test/java/com/harman/ignite/healthcheck/TestHealthMonitor.java b/src/test/java/com/harman/ignite/healthcheck/TestHealthMonitor.java
new file mode 100644
index 0000000..1fffe88
--- /dev/null
+++ b/src/test/java/com/harman/ignite/healthcheck/TestHealthMonitor.java
@@ -0,0 +1,102 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.healthcheck;
+
+/**
+ * Test POJO class for HealthMonitor.
+ *
+ * @see HealthMonitor
+ */
+public class TestHealthMonitor implements HealthMonitor, HealthServiceCallBack {
+
+ private boolean healthy;
+ private boolean needsRestartOnFailure;
+ private boolean enabled;
+ private String monitorName = "TestHealthMonitor";
+ private String metricName = "TestHealthMonitorGuage";
+
+ @Override
+ public boolean isHealthy(boolean forceHealthCheck) {
+ return healthy;
+ }
+
+ @Override
+ public boolean needsRestartOnFailure() {
+ return needsRestartOnFailure;
+ }
+
+ @Override
+ public boolean performRestart() {
+ return false;
+ }
+
+ public void setNeedsRestartOnFailure(boolean needsRestartOnFailure) {
+ this.needsRestartOnFailure = needsRestartOnFailure;
+ }
+
+ public void setHealthy(boolean healthy) {
+ this.healthy = healthy;
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ @Override
+ public String monitorName() {
+ return monitorName;
+ }
+
+ public void setMonitorName(String monitorName) {
+ this.monitorName = monitorName;
+ }
+
+ @Override
+ public String metricName() {
+ return metricName;
+ }
+
+ public void setMetricName(String metricName) {
+ this.metricName = metricName;
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/healthcheck/TestHealthMonitorWithForce.java b/src/test/java/com/harman/ignite/healthcheck/TestHealthMonitorWithForce.java
new file mode 100644
index 0000000..ebe2001
--- /dev/null
+++ b/src/test/java/com/harman/ignite/healthcheck/TestHealthMonitorWithForce.java
@@ -0,0 +1,105 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.healthcheck;
+
+/** Test POJO class for HealthMonitor with force health check.
+ *
+ * @see HealthMonitor
+ */
+public class TestHealthMonitorWithForce implements HealthMonitor {
+
+ private static final int THREE = 3;
+ private boolean healthy;
+ private boolean needsRestartOnFailure;
+ private boolean enabled;
+ private String monitorName = "TestHealthMonitorWithForce";
+ private String metricName = "TestHealthMonitorWithForceGuage";
+ @SuppressWarnings("checkstyle:MemberName")
+ private int i = 0;
+
+ @Override
+ public boolean isHealthy(boolean forceHealthCheck) {
+ if (i > THREE) {
+ return true;
+ }
+ if (forceHealthCheck) {
+ i++;
+ }
+ return false;
+ }
+
+ @Override
+ public String monitorName() {
+ return monitorName;
+ }
+
+ @Override
+ public boolean needsRestartOnFailure() {
+ return needsRestartOnFailure;
+ }
+
+ @Override
+ public String metricName() {
+ return metricName;
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ public void setHealthy(boolean healthy) {
+ this.healthy = healthy;
+ }
+
+ public void setNeedsRestartOnFailure(boolean needsRestartOnFailure) {
+ this.needsRestartOnFailure = needsRestartOnFailure;
+ }
+
+ public void setMonitorName(String monitorName) {
+ this.monitorName = monitorName;
+ }
+
+ public void setMetricName(String metricName) {
+ this.metricName = metricName;
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/healthcheck/TestHealthServiceConfig.java b/src/test/java/com/harman/ignite/healthcheck/TestHealthServiceConfig.java
new file mode 100644
index 0000000..5eaa9af
--- /dev/null
+++ b/src/test/java/com/harman/ignite/healthcheck/TestHealthServiceConfig.java
@@ -0,0 +1,86 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.healthcheck;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+/** Test configuration for initializing TestHealthMonitor and TestHealthMonitorWithForce beans.
+ *
+ * @see HealthServiceStateTest
+ */
+@Configuration
+@ComponentScan(basePackages = { "com.harman.ignite" })
+public class TestHealthServiceConfig {
+
+ /** Bean for TestHealthMonitor.
+ *
+ * @return TestHealthMonitor
+ */
+ @Bean
+ public TestHealthMonitor testHealthMonitor() {
+ TestHealthMonitor monitor1 = new TestHealthMonitor();
+ monitor1.setEnabled(true);
+ return monitor1;
+ }
+
+ /** Bean for TestHealthMonitor.
+ * This should be skipped at the time of init of healthservice as enabled is false.
+ *
+ * @return TestHealthMonitor
+ */
+ @Bean
+ public TestHealthMonitor testHealthMonitor2() {
+ TestHealthMonitor monitor1 = new TestHealthMonitor();
+ monitor1.setEnabled(false);
+ return monitor1;
+ }
+
+ /**
+ * Bean for TestHealthMonitorWithForce.
+ *
+ * @return TestHealthMonitorWithForce
+ */
+ @Bean
+ public TestHealthMonitorWithForce testHealthMonitorWithForce() {
+ TestHealthMonitorWithForce monitor1 = new TestHealthMonitorWithForce();
+ monitor1.setEnabled(true);
+ return monitor1;
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/utils/filter/TestDuplicateExceptionFilter.java b/src/test/java/com/harman/ignite/utils/filter/TestDuplicateExceptionFilter.java
new file mode 100644
index 0000000..f6eeba0
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/filter/TestDuplicateExceptionFilter.java
@@ -0,0 +1,118 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.filter;
+
+import ch.qos.logback.classic.turbo.TurboFilter;
+import ch.qos.logback.core.spi.FilterReply;
+import com.harman.ignite.utils.logger.LoggerUtils;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * This test case is used to test the filter DuplicateExceptionFilter.
+ *
+ * @author vkoul
+ */
+public class TestDuplicateExceptionFilter {
+
+ private static final long SIXTY_THOUSAND = 60000L;
+ private static final long LONG_VALUE_FOR_LOGGER = 2628077220L;
+ private static final Logger LOGGER = LoggerFactory.getLogger(TestDuplicateExceptionFilter.class);
+ private DuplicateExceptionFilter def = null;
+ @Mock
+ private LoggerUtils loggerUtils;
+
+ /**
+ * Setup the test.
+ */
+ @Before
+ public void setUp() {
+ def = new DuplicateExceptionFilter();
+ def.setSuppressTimeInMs(SIXTY_THOUSAND);
+ def.start();
+ }
+
+ /**
+ * This test case calls decide() twice within a minute.
+ *
+ * First invocation to decide() should return NEUTRAL whereas the next invocation should return DENY,
+ * as it is occurring within a minute, for which suppression should happen.
+ */
+ @Test
+ public void testExceptionSuppressed() {
+
+ assertThat(logMessage(def, new IOException())).isEqualTo(FilterReply.NEUTRAL);
+
+ // Now, next log is within one minute, so it should be DENY
+ assertThat(logMessage(def, new IOException())).isEqualTo(FilterReply.DENY);
+ assertThat(def.decide(null, (ch.qos.logback.classic.Logger) LOGGER,
+ null,
+ "",
+ new Object[] { new IOException() }, null))
+ .isEqualTo(FilterReply.DENY);
+
+ ConcurrentHashMap exceptionCache = new ConcurrentHashMap<>();
+ exceptionCache.put(IOException.class.getName() + LOGGER.toString(), LONG_VALUE_FOR_LOGGER);
+ def.setExceptionCache(exceptionCache);
+
+ assertThat(logMessage(def, new IOException())).isEqualTo(FilterReply.NEUTRAL);
+ }
+
+ @Test
+ public void testGetSuppressTimeInMs() {
+ Assert.assertEquals(SIXTY_THOUSAND, def.getSuppressTimeInMs());
+ }
+
+ @After
+ public void tearDown() {
+ def.stop();
+ }
+
+ private FilterReply logMessage(final TurboFilter def, Throwable t) {
+ return def.decide(null, (ch.qos.logback.classic.Logger) LOGGER, null, null, null, t);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/com/harman/ignite/utils/logger/EventLogger1.java b/src/test/java/com/harman/ignite/utils/logger/EventLogger1.java
new file mode 100644
index 0000000..54b21d1
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/EventLogger1.java
@@ -0,0 +1,57 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+/** Thread class for EventLogger1.
+ *
+ * @author AKumar
+ */
+public class EventLogger1 implements Runnable {
+ private static IgniteLogger igniteLogger = IgniteLoggerFactory.getLogger(EventLogger1.class);
+
+ public static IgniteLogger getIgniteLogger() {
+ return igniteLogger;
+ }
+
+ @Override
+ public void run() {
+ igniteLogger.info("Info message from EventLogger1");
+ igniteLogger.trace("Info message from EventLogger1");
+ igniteLogger.debug("Info message from EventLogger1");
+ igniteLogger.error("Error message from EventLogger1", new Exception("exception occurred"));
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/EventLogger2.java b/src/test/java/com/harman/ignite/utils/logger/EventLogger2.java
new file mode 100644
index 0000000..d9eb8f7
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/EventLogger2.java
@@ -0,0 +1,55 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+/** Thread class for EventLogger2.
+ *
+ * @author AKumar
+ */
+public class EventLogger2 implements Runnable {
+
+ private static IgniteLogger igniteLogger = IgniteLoggerFactory.getLogger(EventLogger2.class);
+
+ @Override
+ public void run() {
+ igniteLogger.info("Info message from EventLogger2");
+ igniteLogger.trace("Info message from EventLogger2");
+ igniteLogger.debug("Info message from EventLogger2");
+ igniteLogger.error("Error message from EventLogger2", new Exception("exception occurred"));
+ }
+
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/IgniteLoggerFactoryTest.java b/src/test/java/com/harman/ignite/utils/logger/IgniteLoggerFactoryTest.java
new file mode 100644
index 0000000..51d25ca
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/IgniteLoggerFactoryTest.java
@@ -0,0 +1,55 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.MockitoAnnotations;
+
+/** Test class for IgniteLoggerFactory.
+ *
+ * @see IgniteLoggerFactory
+ */
+public class IgniteLoggerFactoryTest {
+
+ @Test
+ public void testGetLogger() {
+ MockitoAnnotations.initMocks(this);
+ IgniteLogger logger = IgniteLoggerFactory.getLogger(EventLogger1.class);
+ Assert.assertTrue(logger instanceof IgniteLoggerImpl);
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/TestIgniteLogger.java b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLogger.java
new file mode 100644
index 0000000..860bffc
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLogger.java
@@ -0,0 +1,358 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import com.harman.ignite.entities.IgniteEvent;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
+
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test class for IgniteLogger.
+ *
+ * @author AKumar
+ */
+
+public class TestIgniteLogger {
+ private static final int TWO = 2;
+ private static IgniteLoggerImpl igniteLogger =
+ IgniteLoggerImpl.getIgniteLoggerImplInstance(EventLogger2.class);
+ Logger logger;
+
+ /**
+ * Setup method.
+ */
+ @Before
+ public void setup() {
+ logger = Mockito.mock(Logger.class);
+ when(logger.isTraceEnabled()).thenReturn(true);
+ when(logger.isDebugEnabled()).thenReturn(true);
+ when(logger.isInfoEnabled()).thenReturn(true);
+ igniteLogger.setLogger(logger);
+ }
+
+ @Test
+ public void testIgniteLoggersInMap() {
+ Thread igniteEventTh1 = new Thread(new EventLogger1(), "EventLogger1");
+ Thread igniteEventTh2 = new Thread(new EventLogger2(), "EventLogger2");
+ igniteEventTh1.start();
+ igniteEventTh2.start();
+
+ Map igniteLoggersMap = igniteLogger.getIgniteLoggersMap();
+ assertEquals(TWO, igniteLoggersMap.size());
+ Assert.assertTrue(igniteLoggersMap.containsKey(EventLogger1.class.getName()));
+ Assert.assertTrue(igniteLoggersMap.containsKey(EventLogger2.class.getName()));
+ }
+
+ @Test
+ public void testInfo() {
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.info("InfoWithMsg");
+ Mockito.verify(logger).info(arg.capture());
+ assertEquals("InfoWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testInfoWithMsgAndThrowable() {
+ igniteLogger.info("InfoWithMsgAndThrowable", new Throwable());
+ Mockito.verify(logger).info(Mockito.eq("InfoWithMsgAndThrowable"), Mockito.any());
+ }
+
+ @Test
+ public void testInfoWithFormatNArgs() {
+ igniteLogger.info("Display message as: parameter1={}", "value1");
+ Mockito.verify(logger)
+ .info(
+ ArgumentMatchers.contains("Display message as: parameter1={}"),
+ ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testInfoWithIgniteEvent() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.info(igniteEvent, "InfoWithMsgAndThrowable");
+ Mockito.verify(logger).info(ArgumentMatchers.endsWith("InfoWithMsgAndThrowable"));
+ }
+
+ @Test
+ public void testInfoWithIgniteEventNMsgNThrowable() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.info(igniteEvent, "InfoWithIgniteEventnMsgnThrowable", new Throwable());
+ Mockito.verify(logger).info(Mockito.endsWith("InfoWithIgniteEventnMsgnThrowable"), Mockito.any());
+ }
+
+ @Test
+ public void testInfoWithIgniteEventNFormatNargs() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.info(igniteEvent, "Display message as: parameter1={} parameter2={}", "value1", new Object());
+ Mockito.verify(logger)
+ .info(
+ ArgumentMatchers.contains("Display message as: parameter1={}"),
+ ArgumentMatchers.any());
+
+ }
+
+ @Test
+ public void testInfoWithIgniteEventAndCorrId() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ Mockito.when(igniteEvent.getCorrelationId()).thenReturn("correlationIdMock");
+ igniteLogger.info(igniteEvent, "InfoWithMsgAndThrowable");
+ Mockito.verify(logger).info(Mockito.contains("InfoWithMsgAndThrowable"));
+ }
+
+ @Test
+ public void testDebug() {
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.debug("DebugWithMsg");
+ Mockito.verify(logger).debug(arg.capture());
+ assertEquals("DebugWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testDebugWithMsgAndThrowable() {
+ igniteLogger.debug("DebugWithMsgAndThrowable", new Throwable());
+ Mockito.verify(logger).debug(Mockito.eq("DebugWithMsgAndThrowable"), Mockito.any());
+ }
+
+ @Test
+ public void testDebugWithFormatNArgs() {
+ igniteLogger.debug("Display message as: parameter1={}", "value1");
+ Mockito.verify(logger)
+ .debug(
+ ArgumentMatchers.contains("Display message as: parameter1={}"),
+ ArgumentMatchers.any());
+
+ }
+
+ @Test
+ public void testDebugWithIgniteEvent() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.debug(igniteEvent, "DebugWithMsgAndThrowable");
+ Mockito.verify(logger).debug(ArgumentMatchers.endsWith("DebugWithMsgAndThrowable"));
+ }
+
+ @Test
+ public void testDebugWithIgniteEventnMsgNThrowable() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.debug(igniteEvent, "DebugWithIgniteEventnMsgnThrowable", new Throwable());
+ Mockito.verify(logger)
+ .debug(
+ Mockito.endsWith("DebugWithIgniteEventnMsgnThrowable"),
+ Mockito.any());
+ }
+
+ @Test
+ public void testDebugWithIgniteEventNFormatNargs() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.debug(igniteEvent, "Display message as: parameter1={} parameter2={}", "value1", new Object());
+ Mockito.verify(logger).debug(ArgumentMatchers.endsWith("Display message as: parameter1={} parameter2={}"),
+ ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testWarn() {
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.warn("WarnWithMsg");
+ Mockito.verify(logger).warn(arg.capture());
+ assertEquals("WarnWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testWarnWithMsgAndThrowable() {
+ igniteLogger.warn("WarnWithMsgAndThrowable", new Throwable());
+ Mockito.verify(logger).warn(Mockito.eq("WarnWithMsgAndThrowable"), Mockito.any());
+ }
+
+ @Test
+ public void testWarnWithFormatNArgs() {
+ igniteLogger.warn("Display message as: parameter1={}", "value1");
+ Mockito.verify(logger)
+ .warn(
+ ArgumentMatchers.endsWith("Display message as: parameter1={}"),
+ ArgumentMatchers.any());
+
+ }
+
+ @Test
+ public void testWarnWithIgniteEvent() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.warn(igniteEvent, "WarnWithMsgAndThrowable");
+ Mockito.verify(logger).warn(Mockito.endsWith("WarnWithMsgAndThrowable"));
+ }
+
+ @Test
+ public void testWarnWithIgniteEventNMsgNThrowable() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.warn(igniteEvent, "WarnWithIgniteEventnMsgnThrowable", new Throwable());
+ Mockito.verify(logger)
+ .warn(
+ Mockito.endsWith("WarnWithIgniteEventnMsgnThrowable"),
+ Mockito.any());
+ }
+
+ @Test
+ public void testWarnWithIgniteEventNFormatNargs() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.warn(igniteEvent, "Display message as: parameter1={} parameter2={}", "value1", new Object());
+ Mockito.verify(logger)
+ .warn(
+ ArgumentMatchers.endsWith("Display message as: parameter1={} parameter2={}"),
+ ArgumentMatchers.any());
+
+ }
+
+ @Test
+ public void testTrace() {
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.trace("TraceWithMsg");
+ Mockito.verify(logger).trace(arg.capture());
+ assertEquals("TraceWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testTraceWithMsgAndThrowable() {
+ igniteLogger.trace("TraceWithMsgAndThrowable", new Throwable());
+ Mockito.verify(logger).trace(Mockito.eq("TraceWithMsgAndThrowable"), Mockito.any());
+ }
+
+ @Test
+ public void testTraceWithFormatNArgs() {
+ igniteLogger.trace("Display message as: parameter1={}", "value1");
+ Mockito.verify(logger)
+ .trace(
+ ArgumentMatchers.contains("Display message as: parameter1={}"),
+ ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testTraceWithIgniteEvent() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.trace(igniteEvent, "TraceWithMsgAndThrowable");
+ Mockito.verify(logger).trace(ArgumentMatchers.endsWith("TraceWithMsgAndThrowable"));
+ }
+
+ @Test
+ public void testTraceWithIgniteEventNMsgnThrowable() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.trace(igniteEvent, "TraceWithIgniteEventnMsgnThrowable", new Throwable());
+ Mockito.verify(logger)
+ .trace(
+ Mockito.endsWith("TraceWithIgniteEventnMsgnThrowable"),
+ Mockito.any());
+ }
+
+ @Test
+ public void testTraceWithIgniteEventNFormatNargs() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.trace(igniteEvent, "Display message as: parameter1={} parameter2={}", "value1", new Object());
+ Mockito.verify(logger)
+ .trace(
+ ArgumentMatchers.endsWith("Display message as: parameter1={} parameter2={}"),
+ ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testError() {
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.error("ErrorWithMsg");
+ Mockito.verify(logger).error(arg.capture());
+ assertEquals("ErrorWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testErrorWithMsgAndThrowable() {
+ igniteLogger.error("ErrorWithMsgAndThrowable", new Throwable());
+ Mockito.verify(logger)
+ .error(
+ Mockito.eq("ErrorWithMsgAndThrowable"),
+ Mockito.any());
+ }
+
+ @Test
+ public void testErrorWithFormatnArgs() {
+ igniteLogger.error("Display message as: parameter1={}", "value1");
+ Mockito.verify(logger)
+ .error(
+ ArgumentMatchers.contains("Display message as: parameter1={}"),
+ ArgumentMatchers.any());
+
+ }
+
+ @Test
+ public void testErrorWithIgniteEvent() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.error(igniteEvent, "ErrorWithMsgAndThrowable");
+ Mockito.verify(logger).error(ArgumentMatchers.endsWith("ErrorWithMsgAndThrowable"));
+ }
+
+ @Test
+ public void testErrorWithIgniteEventNMsgNThrowable() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.error(igniteEvent, "ErrorWithIgniteEventnMsgnThrowable", new Throwable());
+ Mockito.verify(logger)
+ .error(
+ Mockito.endsWith("ErrorWithIgniteEventnMsgnThrowable"),
+ Mockito.any());
+ }
+
+ @Test
+ public void testErrorWithIgniteEventNFormatNArgs() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.error(igniteEvent, "Display message as: parameter1={} parameter2={}", "value1", new Object());
+ Mockito.verify(logger)
+ .error(
+ ArgumentMatchers.endsWith("Display message as: parameter1={} parameter2={}"),
+ ArgumentMatchers.any());
+
+ }
+
+ @Test
+ public void testErrorWithIgniteEventNMsgNException() {
+ IgniteEvent igniteEvent = Mockito.mock(IgniteEvent.class);
+ igniteLogger.error(igniteEvent, "EXCEPTION", new Exception());
+ Mockito.verify(logger).error(Mockito.endsWith("EXCEPTION"), Mockito.any());
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerDebug.java b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerDebug.java
new file mode 100644
index 0000000..d8ce985
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerDebug.java
@@ -0,0 +1,79 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.internal.verification.Times;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/** Test class for IgniteLogger for debug.
+ *
+ * @author AKumar
+ */
+
+public class TestIgniteLoggerDebug {
+ private static IgniteLoggerImpl igniteLogger = IgniteLoggerImpl.getIgniteLoggerImplInstance(EventLogger2.class);
+ Logger logger;
+
+ @Before
+ public void setup() {
+ logger = Mockito.mock(Logger.class);
+ igniteLogger.setLogger(logger);
+ }
+
+ @Test
+ public void testIgniteLoggersWhenDebugEnabled() {
+ when(logger.isDebugEnabled()).thenReturn(true);
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.debug("DebugWithMsg");
+ Mockito.verify(logger).debug(arg.capture());
+ assertEquals("DebugWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testIgniteLoggersWhenDebugDisabled() {
+ when(logger.isDebugEnabled()).thenReturn(false);
+ igniteLogger.debug("DebugWithMsg");
+ Mockito.verify(logger, new Times(0)).debug("DebugWithMsg");
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerError.java b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerError.java
new file mode 100644
index 0000000..ef30e57
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerError.java
@@ -0,0 +1,79 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.internal.verification.Times;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/** Test class for IgniteLogger for error.
+ *
+ * @author AKumar
+ */
+
+public class TestIgniteLoggerError {
+ private static IgniteLoggerImpl igniteLogger = IgniteLoggerImpl.getIgniteLoggerImplInstance(EventLogger2.class);
+ Logger logger;
+
+ @Before
+ public void setup() {
+ logger = Mockito.mock(Logger.class);
+ igniteLogger.setLogger(logger);
+ }
+
+ @Test
+ public void testIgniteLoggersWhenErrorEnabled() {
+ when(logger.isErrorEnabled()).thenReturn(true);
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.error("ErrorWithMsg");
+ Mockito.verify(logger).error(arg.capture());
+ assertEquals("ErrorWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testIgniteLoggersWhenErrorDisabled() {
+ when(logger.isErrorEnabled()).thenReturn(false);
+ igniteLogger.error("ErrorWithMsg");
+ Mockito.verify(logger, new Times(1)).error("ErrorWithMsg");
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerInfo.java b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerInfo.java
new file mode 100644
index 0000000..fac9753
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerInfo.java
@@ -0,0 +1,80 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.internal.verification.Times;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test class for IgniteLogger for info.
+ *
+ * @author AKumar
+ */
+
+public class TestIgniteLoggerInfo {
+ private static IgniteLoggerImpl igniteLogger = IgniteLoggerImpl.getIgniteLoggerImplInstance(EventLogger2.class);
+ Logger logger;
+
+ @Before
+ public void setup() {
+ logger = Mockito.mock(Logger.class);
+ igniteLogger.setLogger(logger);
+ }
+
+ @Test
+ public void testIgniteLoggersWhenInfoEnabled() {
+ when(logger.isInfoEnabled()).thenReturn(true);
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.info("InfoWithMsg");
+ Mockito.verify(logger).info(arg.capture());
+ assertEquals("InfoWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testIgniteLoggersWhenInfoDisabled() {
+ when(logger.isInfoEnabled()).thenReturn(false);
+ igniteLogger.info("InfoWithMsg");
+ Mockito.verify(logger, new Times(0)).info("InfoWithMsg");
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerTrace.java b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerTrace.java
new file mode 100644
index 0000000..127ae27
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerTrace.java
@@ -0,0 +1,80 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.internal.verification.Times;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test class for IgniteLogger for trace.
+ *
+ * @author AKumar
+ */
+
+public class TestIgniteLoggerTrace {
+ private static IgniteLoggerImpl igniteLogger = IgniteLoggerImpl.getIgniteLoggerImplInstance(EventLogger2.class);
+ Logger logger;
+
+ @Before
+ public void setup() {
+ logger = Mockito.mock(Logger.class);
+ igniteLogger.setLogger(logger);
+ }
+
+ @Test
+ public void testIgniteLoggersWhenTraceEnabled() {
+ when(logger.isTraceEnabled()).thenReturn(true);
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.trace("TraceWithMsg");
+ Mockito.verify(logger).trace(arg.capture());
+ assertEquals("TraceWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testIgniteLoggersWhenTraceDisabled() {
+ when(logger.isTraceEnabled()).thenReturn(false);
+ igniteLogger.trace("TraceWithMsg");
+ Mockito.verify(logger, new Times(0)).trace("TraceWithMsg");
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerWarn.java b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerWarn.java
new file mode 100644
index 0000000..3de8b85
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/logger/TestIgniteLoggerWarn.java
@@ -0,0 +1,81 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.logger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.internal.verification.Times;
+import org.slf4j.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test class for IgniteLogger for warn.
+ *
+ * @author AKumar
+ *
+ */
+
+public class TestIgniteLoggerWarn {
+ private static IgniteLoggerImpl igniteLogger = IgniteLoggerImpl.getIgniteLoggerImplInstance(EventLogger2.class);
+ Logger logger;
+
+ @Before
+ public void setup() {
+ logger = Mockito.mock(Logger.class);
+ igniteLogger.setLogger(logger);
+ }
+
+ @Test
+ public void testIgniteLoggersWhenWarnEnabled() {
+ when(logger.isWarnEnabled()).thenReturn(true);
+ ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
+ igniteLogger.warn("WarnWithMsg");
+ Mockito.verify(logger).warn(arg.capture());
+ assertEquals("WarnWithMsg", arg.getValue());
+ }
+
+ @Test
+ public void testIgniteLoggersWhenWarnDisabled() {
+ when(logger.isWarnEnabled()).thenReturn(false);
+ igniteLogger.warn("WarnWithMsg");
+ Mockito.verify(logger, new Times(1)).warn("WarnWithMsg");
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/GenericIgniteGuageTest.java b/src/test/java/com/harman/ignite/utils/metrics/GenericIgniteGuageTest.java
new file mode 100644
index 0000000..10ce899
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/GenericIgniteGuageTest.java
@@ -0,0 +1,169 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.Gauge;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+
+import java.util.List;
+
+/**
+ * Test class for IgniteGuageTest.
+ *
+ * @see IgniteGuageTest
+ */
+public class GenericIgniteGuageTest {
+
+ @InjectMocks
+ IgniteGuageTest guage = new IgniteGuageTest();
+ private static final double THREE = 3.0;
+ private static final double THREE_DOT_FIVE = 3.5;
+ private static final double FIVE = 5.0;
+ private static final double SEVEN = 7.0;
+ private static final double NINE = 9.0;
+ private static final double TEN = 10.0;
+ private final String name = null;
+ private final String[] labels = { "node", "taskId" };
+
+ /**
+ * Setup method to initialize the mocks.
+ */
+ @Before
+ public void setup() {
+ MockitoAnnotations.initMocks(this);
+ CollectorRegistry.defaultRegistry.clear();
+ System.out.println("In before");
+ }
+
+ @Test
+ public void testCreateGuage() {
+ guage.createGauge("test_guage", "test_guage", labels);
+ Gauge newGuage = guage.getGuage();
+ List samples = newGuage.collect();
+
+ Assert.assertTrue(guage.getIsInitialized());
+ samples.forEach(sample -> {
+ Assert.assertEquals("test_guage", sample.name);
+ });
+
+ guage.createGauge(name, name, labels);
+ }
+
+ @Test
+ public void testInc() {
+ guage.createGauge("test_guage1", "test_guage1", labels);
+ double value = guage.get(labels);
+
+ Assert.assertEquals(0.0, value, 0.0);
+
+ guage.inc(labels);
+ value = guage.get(labels);
+
+ Assert.assertEquals(1.0, value, 0.0);
+ }
+
+ @Test
+ public void testIncBySomeValue() {
+ guage.createGauge("test_guage2", "test_guage2", labels);
+ Assert.assertEquals(0.0, guage.get(labels), 0.0);
+
+ guage.inc(FIVE, labels);
+
+ Assert.assertEquals(FIVE, guage.get(labels), 0.0);
+ }
+
+ @Test
+ public void testDecBySomeValue() {
+ guage.createGauge("test_guage3", "test_guage3", labels);
+ guage.inc(TEN, labels);
+
+ Assert.assertEquals(TEN, guage.get(labels), 0.0);
+
+ guage.dec(THREE, labels);
+
+ Assert.assertEquals(SEVEN, guage.get(labels), 0.0);
+ }
+
+ @Test
+ public void testDec() {
+ guage.createGauge("test_guage4", "test_guage4", labels);
+ guage.inc(TEN, labels);
+
+ Assert.assertEquals(TEN, guage.get(labels), 0.0);
+
+ guage.dec(labels);
+
+ Assert.assertEquals(NINE, guage.get(labels), 0.0);
+ }
+
+ @Test
+ public void testSetGaugeValue() {
+ guage.createGauge("test_guage5", "test_guage5", labels);
+
+ Assert.assertEquals(0.0, guage.get(labels), 0.0);
+
+ guage.set(THREE_DOT_FIVE, labels);
+
+ Assert.assertEquals(THREE_DOT_FIVE, guage.get(labels), 0.0);
+ }
+
+ @Test
+ public void testClear() {
+ guage.createGauge("test_guage6", "test_guage6", labels);
+ guage.set(SEVEN, labels);
+
+ Assert.assertEquals(SEVEN, guage.get(labels), 0.0);
+
+ guage.clear();
+
+ Assert.assertEquals(0.0, guage.get(labels), 0.0);
+ }
+
+ /** Test Gauge class.
+ *
+ * @see IgniteGuageTest
+ */
+ public static class IgniteGuageTest extends AbstractIgniteGauge {
+
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/IgniteCounterTest.java b/src/test/java/com/harman/ignite/utils/metrics/IgniteCounterTest.java
new file mode 100644
index 0000000..ebbafe0
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/IgniteCounterTest.java
@@ -0,0 +1,93 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.Counter;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * Test class for TestCounter.
+ *
+ * @see TestCounter
+ */
+public class IgniteCounterTest {
+ String name = "test_counter";
+ String[] labels = { "node", "taskId" };
+
+ private final TestCounter testCounter = new TestCounter();
+
+ @Before
+ public void setup() {
+ CollectorRegistry.defaultRegistry.clear();
+ }
+
+ @Test
+ public void testCreateCounter() {
+ testCounter.createCounter(name, labels);
+ Counter counter = testCounter.getCounter();
+ List samples = counter.collect();
+
+ samples.forEach(sample -> {
+ Assert.assertEquals(name, sample.name);
+ });
+
+ //again trying to create counter that's already created, won't do anything
+ testCounter.createCounter(name, labels);
+ }
+
+ @Test
+ public void testInc() {
+ testCounter.createCounter(name, labels);
+ Assert.assertEquals(0.0, testCounter.get(labels), 0.0);
+ testCounter.inc(labels);
+ Assert.assertEquals(1.0, testCounter.get(labels), 0.0);
+ }
+
+ /** Test class for IgniteCounter.
+ *
+ * @see IgniteCounter
+ */
+ public static class TestCounter extends IgniteCounter {
+
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/IgniteErrorCounterTest.java b/src/test/java/com/harman/ignite/utils/metrics/IgniteErrorCounterTest.java
new file mode 100644
index 0000000..361eb7e
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/IgniteErrorCounterTest.java
@@ -0,0 +1,115 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.Counter;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+
+import java.util.List;
+
+/**
+ * Test class for IgniteErrorCounter.
+ *
+ * @see IgniteErrorCounter
+ */
+public class IgniteErrorCounterTest {
+
+ @InjectMocks
+ private IgniteErrorCounter igniteCounter;
+ private static final double FIVE = 5.0;
+ private final String name = "test_count";
+ private final String[] labels = { "node", "taskId", "IllegalArgumentException" };
+
+ @Before
+ public void setup() {
+ MockitoAnnotations.initMocks(this);
+ CollectorRegistry.defaultRegistry.clear();
+ }
+
+ @Test
+ public void testCreateCounter() {
+ igniteCounter.createCounter(name, name, labels);
+
+ Counter counter = igniteCounter.getCounter();
+ List samples = counter.collect();
+ Assert.assertTrue(igniteCounter.isInitialized());
+ for (MetricFamilySamples sample : samples) {
+ Assert.assertEquals("error_count", sample.name);
+ }
+
+ }
+
+ @Test
+ public void testIncErrorCounter() {
+ //create a counter with initial metric value as 0.0
+ igniteCounter.createCounter(name, name, labels);
+ igniteCounter.setNodeName("node");
+ //increment the metric value of the counter with labels = {"node","taskId","IllegalArgumentException"} by 1
+ igniteCounter.inc(labels);
+
+ Assert.assertEquals(1.0, igniteCounter.get(labels), 0.0);
+ }
+
+ @Test
+ public void testIncErrorCounterBySomeValue() {
+ //create a counter with initial metric value as 0.0
+ igniteCounter.createCounter(name, name, labels);
+ igniteCounter.setNodeName("node");
+ //increment the metric value of the counter with labels = {"node","taskId","IllegalArgumentException"} by 5
+ igniteCounter.inc(FIVE, labels);
+
+ //since initial value was 0.0 and we incremented the metric value by 5.0, hence asserting as 5.0
+ Assert.assertEquals(FIVE, igniteCounter.get(labels), 0.0);
+ }
+
+ @Test
+ public void testClearCounter() {
+ igniteCounter.createCounter(name, name, labels);
+ igniteCounter.setNodeName("node");
+ igniteCounter.inc(FIVE, labels);
+
+ Assert.assertEquals(FIVE, igniteCounter.get(labels), 0.0);
+ igniteCounter.clear();
+ Assert.assertEquals(0.0, igniteCounter.get(labels), 0.0);
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/IgniteGuageTest.java b/src/test/java/com/harman/ignite/utils/metrics/IgniteGuageTest.java
new file mode 100644
index 0000000..f94ef68
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/IgniteGuageTest.java
@@ -0,0 +1,104 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.Gauge;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+
+import java.util.List;
+
+/**
+ * Test class for IgniteGuageTest.
+ *
+ * @see TestGuage
+ */
+public class IgniteGuageTest {
+
+ private static final double TEN_DOT_FIVE = 10.5;
+ private final String name = "test_guage";
+ private final String[] labels = { "test_metric", "node", "monitorname" };
+
+ @InjectMocks
+ private TestGuage testGuage = new TestGuage();
+
+ @Before
+ public void setup() {
+ MockitoAnnotations.initMocks(this);
+ CollectorRegistry.defaultRegistry.clear();
+ }
+
+ @Test
+ public void testCreateGuage() {
+ testGuage.createGuage(name, labels);
+ Gauge guage = testGuage.getIgniteGuageMetric();
+
+ Assert.assertTrue(guage != null && guage instanceof Gauge);
+
+ List samples = guage.collect();
+ for (MetricFamilySamples sample : samples) {
+ Assert.assertEquals("test_guage", sample.name);
+ }
+
+ //trying to create a guage that already exists, it won't create and publish a WARN logger
+ testGuage.createGuage(name, labels);
+ }
+
+ @Test
+ public void testSetValueOnGuage() {
+ testGuage.createGuage(name, labels);
+ Gauge guage = testGuage.getIgniteGuageMetric();
+ testGuage.setIgniteGuageMetric(guage);
+ testGuage.set(TEN_DOT_FIVE, labels);
+ double value = testGuage.get(labels);
+
+ Assert.assertEquals(TEN_DOT_FIVE, value, 0);
+ }
+
+ /** Test class for IgniteGuage.
+ *
+ * @see IgniteGuage
+ */
+ public static class TestGuage extends IgniteGuage {
+
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/IgniteRocksDBGuageTest.java b/src/test/java/com/harman/ignite/utils/metrics/IgniteRocksDBGuageTest.java
new file mode 100644
index 0000000..5a3a482
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/IgniteRocksDBGuageTest.java
@@ -0,0 +1,67 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.Gauge;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+
+import java.util.List;
+
+/** Test class for IgniteRocksDBGuage.
+ *
+ * @see IgniteRocksDBGuage
+ */
+@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
+public class IgniteRocksDBGuageTest {
+ @InjectMocks
+ private IgniteRocksDBGuage guage = new IgniteRocksDBGuage();
+
+ @Test
+ public void testSetup() {
+ guage.setup();
+ Gauge testGuage = guage.getIgniteGuageMetric();
+ Assert.assertTrue(testGuage != null && testGuage instanceof Gauge);
+
+ List samples = testGuage.collect();
+ for (MetricFamilySamples familySample : samples) {
+ Assert.assertEquals("rocksdb_metric", familySample.name);
+ }
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/InternalCacheGuageTest.java b/src/test/java/com/harman/ignite/utils/metrics/InternalCacheGuageTest.java
new file mode 100644
index 0000000..20b2ad6
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/InternalCacheGuageTest.java
@@ -0,0 +1,91 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.Collector.MetricFamilySamples.Sample;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.Gauge;
+import org.junit.Assert;
+import org.junit.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.List;
+
+/** Test class for InternalCacheGuage.
+ *
+ * @see InternalCacheGuage
+ */
+public class InternalCacheGuageTest {
+
+ private final InternalCacheGuage cacheGuage = new InternalCacheGuage();
+ private static final double TEN = 10.0;
+
+ @Test
+ public void testSetupIfMetricsEnabled() {
+ ReflectionTestUtils.setField(cacheGuage, "internalMetricsEnabled", true);
+ ReflectionTestUtils.setField(cacheGuage, "prometheusEnabled", true);
+
+ cacheGuage.setup();
+ Gauge guage = cacheGuage.getIgniteGuageMetric();
+ Assert.assertNotNull(guage);
+
+ List samples = guage.collect();
+ for (MetricFamilySamples familySample : samples) {
+ Assert.assertEquals("internal_cache_size_metric", familySample.name);
+ }
+ }
+
+ @Test
+ public void testSet() {
+ //Below code is to avoid "Collector already registered the metric..." error.
+ CollectorRegistry.defaultRegistry.clear();
+ ReflectionTestUtils.setField(cacheGuage, "internalMetricsEnabled", true);
+ ReflectionTestUtils.setField(cacheGuage, "prometheusEnabled", true);
+
+ cacheGuage.setup();
+ cacheGuage.set(TEN, "test_cache", "test_svc", "test_node", "0_1");
+ Gauge guage = cacheGuage.getIgniteGuageMetric();
+
+ List samples = guage.collect();
+ for (MetricFamilySamples familySample : samples) {
+ for (Sample sample : familySample.samples) {
+ Assert.assertEquals(TEN, sample.value, 0.0);
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/harman/ignite/utils/metrics/TestGenericIgniteHistogram.java b/src/test/java/com/harman/ignite/utils/metrics/TestGenericIgniteHistogram.java
new file mode 100644
index 0000000..d78b2be
--- /dev/null
+++ b/src/test/java/com/harman/ignite/utils/metrics/TestGenericIgniteHistogram.java
@@ -0,0 +1,236 @@
+/*
+ * *******************************************************************************
+ *
+ * Copyright (c) 2023-24 Harman International
+ *
+ *
+ *
+ * Licensed 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.
+ *
+ *
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * *******************************************************************************
+ */
+
+package com.harman.ignite.utils.metrics;
+
+import io.prometheus.client.Collector;
+import io.prometheus.client.Collector.MetricFamilySamples;
+import io.prometheus.client.Collector.MetricFamilySamples.Sample;
+import io.prometheus.client.Histogram;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.function.Supplier;
+
+/**
+ * This class tests basic functionality of Histogram.
+ * Key point to note while testing:
+ *
+ *
+ * - Create Histogram.
+ * - Do observe.
+ * - Check data on Collector.
+ *
+ *
+ * @author vkoul
+ *
+ */
+
+public class TestGenericIgniteHistogram {
+ private static final double TWO = 2.0;
+ private static final double THREE = 3.0;
+ private static final int TEN = 10;
+ private static final int HUNDRED = 100;
+ private static final long TWO_THOUSAND = 2000L;
+ private static final long THREE_THOUSAND = 3000L;
+ private static final double HUNDRED_DOUBLE = 100.0;
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testObserveExtended() throws Exception {
+ GenericIgniteHistogram genericIgniteHistogram = new GenericIgniteHistogram(
+ "testHistogram",
+ "testHistogramDoubleHelp",
+ new double[] { HUNDRED },
+ "testHistogramDoubleLabel");
+ String[] labels = { "testHistogramDoubleLabel" };
+ Assert.assertEquals("Test invocation", genericIgniteHistogram.observeExtended(new Callable() {
+ @Override
+ public String call() {
+ return "Test invocation";
+ }
+ }, labels));
+ }
+
+ /**
+ * This test cases tests observe(Double...) functionality.
+ */
+ @Test
+ public void testObserveDouble() {
+ GenericIgniteHistogram genericIgniteHistogram = new GenericIgniteHistogram(
+ "testHistogramDouble",
+ "testHistogramDoubleHelp",
+ new double[] { HUNDRED },
+ "testHistogramDoubleLabel");
+ Histogram hg = genericIgniteHistogram.getHistogram();
+ // Observe a value.
+ genericIgniteHistogram.observe(HUNDRED, "testHistogramDoubleLabel");
+ // Collect all metric from this Collector (Histogram).
+ List lists = hg.collect();
+
+ // Should be one, since we observed only once.
+ Assert.assertEquals(1, lists.size());
+ for (MetricFamilySamples mfs : lists) {
+ // Sanity check.
+ Assert.assertEquals("testHistogramDoubleHelp", mfs.help);
+ Assert.assertEquals("testHistogramDouble", mfs.name);
+ Assert.assertEquals(Collector.Type.HISTOGRAM, mfs.type);
+
+ // Collect sample.
+ List samples = mfs.samples;
+
+ // Iterate through all Sample and do sanity check.
+ // Refer to io.prometheus.client.Collector and
+ // io.prometheus.client.Collector.MetricFamilySamples.Sample for
+ // full details.
+ for (Sample sample : samples) {
+ switch (sample.name) {
+ // Test _count for metric "testHistogram"
+ case "testHistogramDouble_count":
+ Assert.assertEquals(1.0, sample.value, 0);
+ break;
+ // Test _sum for metric "testHistogram"
+ case "testHistogramDouble_sum":
+ Assert.assertEquals(HUNDRED_DOUBLE, sample.value, 0);
+ break;
+ default:
+ // do nothing
+ }
+ }
+ }
+ }
+
+ /**
+ * This test cases tests observe(Supplier...) functionality.
+ */
+ @Test
+ public void testObserveSupplier() {
+ GenericIgniteHistogram genericIgniteHistogram = new GenericIgniteHistogram(
+ "testHistogramSupplier",
+ "testHistogramSupplierHelp",
+ new double[] { HUNDRED },
+ "testHistogramSupplierLabel");
+ Histogram hg = genericIgniteHistogram.getHistogram();
+ genericIgniteHistogram.observe(new Supplier() {
+ @Override
+ public Integer get() {
+ try {
+ // Forcefully sleeping for 2 seconds
+ Thread.sleep(TWO_THOUSAND);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ return TEN;
+ }
+ }, "testHistogramSupplierLabel");
+
+ List lists = hg.collect();
+ Assert.assertEquals(1, lists.size());
+ for (MetricFamilySamples mfs : lists) {
+ Assert.assertEquals("testHistogramSupplierHelp", mfs.help);
+ Assert.assertEquals("testHistogramSupplier", mfs.name);
+ Assert.assertEquals(Collector.Type.HISTOGRAM, mfs.type);
+
+ List samples = mfs.samples;
+ for (Sample sample : samples) {
+ switch (sample.name) {
+ case "testHistogramSupplier_count":
+ Assert.assertEquals(1.0, sample.value, 0);
+ break;
+ case "testHistogramSupplier_sum":
+ System.out.println("sample.value is ---> " + sample.value);
+ // This means it took between 2-3 seconds. 2 seconds minimum
+ // since we forcefully slept for 2 seconds.
+ Assert.assertEquals(TWO, sample.value, 1);
+ break;
+ default:
+ // do nothing
+ }
+ }
+ }
+ }
+
+ /**
+ * This test cases tests observe(Runnable...) functionality.
+ */
+ @Test
+ public void testObserveRunnable() {
+ GenericIgniteHistogram genericIgniteHistogram = new GenericIgniteHistogram(
+ "testHistogramRunnable",
+ "testHistogramRunnableHelp",
+ new double[] { HUNDRED },
+ "testHistogramRunnableLabel");
+ Histogram hg = genericIgniteHistogram.getHistogram();
+ genericIgniteHistogram.observe(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ // Forcefully sleeping for 3 seconds
+ Thread.sleep(THREE_THOUSAND);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }, "testHistogramRunnableLabel");
+
+ List lists = hg.collect();
+ Assert.assertEquals(1, lists.size());
+ for (MetricFamilySamples mfs : lists) {
+ Assert.assertEquals("testHistogramRunnableHelp", mfs.help);
+ Assert.assertEquals("testHistogramRunnable", mfs.name);
+ Assert.assertEquals(Collector.Type.HISTOGRAM, mfs.type);
+
+ List samples = mfs.samples;
+ for (Sample sample : samples) {
+ switch (sample.name) {
+ case "testHistogramRunnable_count":
+ Assert.assertEquals(1.0, sample.value, 0);
+ break;
+ case "testHistogramRunnable_sum":
+ System.out.println("sample.value is ---> " + sample.value);
+ // This means it took between 3-4 seconds. 3 seconds minimum
+ // since we forcefully slept for 3 seconds.
+ Assert.assertEquals(THREE, sample.value, 1);
+ break;
+ default:
+ // do nothing
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/resources/logback.xml b/src/test/resources/logback.xml
new file mode 100644
index 0000000..a9cde56
--- /dev/null
+++ b/src/test/resources/logback.xml
@@ -0,0 +1,81 @@
+
+
+
+
+
+ 60000
+
+
+
+
+
+ %d{HH:mm:ss.SSS} [%thread] %c{1} %-5level - %msg
+ %ex{full} %n
+
+
+
+
+
+ 1000000
+ 20
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/test/resources/property-diagnostic-test-2.properties b/src/test/resources/property-diagnostic-test-2.properties
new file mode 100644
index 0000000..33e277b
--- /dev/null
+++ b/src/test/resources/property-diagnostic-test-2.properties
@@ -0,0 +1,43 @@
+#* *******************************************************************************
+#*
+#* Copyright (c) 2023-24 Harman International
+#*
+#*
+#*
+#* Licensed 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.
+#*
+#*
+#*
+#* SPDX-License-Identifier: Apache-2.0
+#*
+#* *******************************************************************************
+mongodb.vault.enabled=true
+vault.server.ipaddress=10.0.0.167
+vault.server.port.number=8200
+vault.environment=dev
+vault.secret.folder=kafka-redis-connector
+diagnostic.mongodb.vault.enabled=true
+diagnostic.vault.server.ipaddress=10.0.0.167
+diagnostic.vault.server.port.number=8200
+diagnostic.vault.environment=dev2
+diagnostic.vault.secret.folder=kafka-redis-connector1
\ No newline at end of file
diff --git a/src/test/resources/property-diagnostic-test.properties b/src/test/resources/property-diagnostic-test.properties
new file mode 100644
index 0000000..76c7403
--- /dev/null
+++ b/src/test/resources/property-diagnostic-test.properties
@@ -0,0 +1,83 @@
+#* *******************************************************************************
+#*
+#* Copyright (c) 2023-24 Harman International
+#*
+#*
+#*
+#* Licensed 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.
+#*
+#*
+#*
+#* SPDX-License-Identifier: Apache-2.0
+#*
+#* *******************************************************************************
+mongodb.hosts=localhost
+mongodb.port=27017
+mongodb.username=admin
+mongodb.password=password
+mongodb.auth.db=admin
+mongodb.name=admin
+mongodb.pool.max.size=1
+mongodb.max.wait.time.ms=60000
+mongodb.connection.timeout.ms=60000
+mongodb.socket.timeout.ms=60000
+mongodb.max.connections.per.host=200
+mongodb.block.threads.allowed.multiplier=10
+mongodb.read.preference=secondaryPreferred
+morphia.map.packages=com.harman.ignite.dao
+mongodb.server.selection.timeout=60000
+#Comma separated fully qualified names for Morphia converters
+morphia.converters.fqn=com.harman.ignite.dao.mongodb.BytesBufferConverter
+mongodb.client.cleanup.interval.ms=10000
+mongodb.client.create.retry.count=3
+#Assumed time interval for running threads to release the old mongo client before forced close.
+mongodb.client.close.wait.interval.ms=60000
+mongodb.taggable.read.preference.enabled=false
+mongodb.read.preference.tag=
+health.mongo.monitor.enabled=true
+health.mongo.needs.restart.on.failure=true
+diagnostic.mongodb.hosts=localhost123
+diagnostic.mongodb.port=27018
+diagnostic.mongodb.username=admin123
+diagnostic.mongodb.password=password
+diagnostic.mongodb.auth.db=admin
+diagnostic.mongodb.name=admin
+diagnostic.mongodb.pool.max.size=1
+diagnostic.mongodb.max.wait.time.ms=60000
+diagnostic.mongodb.connection.timeout.ms=60000
+diagnostic.mongodb.socket.timeout.ms=60000
+diagnostic.mongodb.max.connections.per.host=200
+diagnostic.mongodb.block.threads.allowed.multiplier=10
+diagnostic.mongodb.read.preference=secondaryPreferred
+diagnostic.morphia.map.packages=com.harman.ignite.dao
+diagnostic.mongodb.server.selection.timeout=60000
+#Comma separated fully qualified names for Morphia converters
+diagnostic.morphia.converters.fqn=com.harman.ignite.dao.mongodb.BytesBufferConverter
+diagnostic.mongodb.client.cleanup.interval.ms=10000
+diagnostic.mongodb.client.create.retry.count=3
+#Assumed time interval for running threads to release the old mongo client before forced close.
+diagnostic.mongodb.client.close.wait.interval.ms=60000
+diagnostic.mongodb.taggable.read.preference.enabled=false
+diagnostic.mongodb.read.preference.tag=primary_region
+diagnostic.health.mongo.monitor.enabled=true
+diagnostic.health.mongo.needs.restart.on.failure=true
\ No newline at end of file
diff --git a/target/classes/META-INF/MANIFEST.MF b/target/classes/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..02782f6
--- /dev/null
+++ b/target/classes/META-INF/MANIFEST.MF
@@ -0,0 +1,5 @@
+Manifest-Version: 1.0
+Built-By: karora
+Build-Jdk: 15.0.2
+Created-By: Maven Integration for Eclipse
+
](./images/logo.png)
+
+# Utils
+`Utils` project consists frequently used utilities for ECSP project and provides the below functionalities to a service.
+[](https://github.com/eclipse-ecsp/utils/actions/workflows/maven-publish.yml)
+[](https://github.com/eclipse-ecsp/utils/actions/workflows/license-compliance.yml)
+
+1. Centralized logging.
+2. Health checks.
+3. Diagnostic data reporting.
+4. Application Metrics - counters, gauges and histograms.
+
+# Table of Contents
+* [Getting Started](#getting-started)
+* [Usage](#usage)
+* [How to contribute](#how-to-contribute)
+* [Built with Dependencies](#built-with-dependencies)
+* [Code of Conduct](#code-of-conduct)
+* [Authors](#authors)
+* [Security Contact Information](#security-contact-information)
+* [Support](#support)
+* [Troubleshooting](#troubleshooting)
+* [License](#license)
+* [Announcements](#announcements)
+
+
+## Getting Started
+
+To build the project in the local working directory after the project has been cloned/forked, run:
+
+```mvn clean install```
+
+from the command line interface.
+
+### Prerequisites
+
+1. Maven
+2. Java 17
+
+### Installation
+
+[How to set up maven](https://maven.apache.org/install.html)
+
+[Install Java](https://adoptium.net/installation/)
+
+### Running the tests
+
+```mvn test```
+
+### Deployment
+
+`utils` project serves as a library for the services. It is not meant to be deployed as a service in any cloud environment.
+
+## Usage
+Add the following dependency in the target project
+```
+