diff --git a/src/main/java/org/opensearch/performanceanalyzer/config/PerformanceAnalyzerController.java b/src/main/java/org/opensearch/performanceanalyzer/config/PerformanceAnalyzerController.java index d7b2eeec..fa0937d0 100644 --- a/src/main/java/org/opensearch/performanceanalyzer/config/PerformanceAnalyzerController.java +++ b/src/main/java/org/opensearch/performanceanalyzer/config/PerformanceAnalyzerController.java @@ -31,6 +31,7 @@ public class PerformanceAnalyzerController { // This file should contain "true" or "false", indicating whether batch metrics is currently // enabled or not. private static final String BATCH_METRICS_ENABLED_CONF = "batch_metrics_enabled.conf"; + private static final String THREAD_CONTENTION_MONITORING_ENABLED_CONF = "thread_contention_monitoring_enabled.conf"; private static final Logger LOG = LogManager.getLogger(PerformanceAnalyzerController.class); public static final int DEFAULT_NUM_OF_SHARDS_PER_COLLECTION = 0; @@ -38,11 +39,13 @@ public class PerformanceAnalyzerController { private boolean rcaEnabled; private boolean loggingEnabled; private boolean batchMetricsEnabled; + private boolean threadContentionMonitoringEnabled; private volatile int shardsPerCollection; private static final boolean paEnabledDefaultValue = false; private static final boolean rcaEnabledDefaultValue = true; private static final boolean loggingEnabledDefaultValue = false; private static final boolean batchMetricsEnabledDefaultValue = false; + private static final boolean threadContentionMonitoringEnabledDefaultValue = false; private final ScheduledMetricCollectorsExecutor scheduledMetricCollectorsExecutor; public PerformanceAnalyzerController( @@ -52,6 +55,7 @@ public PerformanceAnalyzerController( initRcaStateFromConf(); initLoggingStateFromConf(); initBatchMetricsStateFromConf(); + initThreadContentionMonitoringStateFromConf(); shardsPerCollection = DEFAULT_NUM_OF_SHARDS_PER_COLLECTION; } @@ -88,6 +92,10 @@ public boolean isBatchMetricsEnabled() { return batchMetricsEnabled; } + public boolean isThreadContentionMonitoringEnabled() { + return threadContentionMonitoringEnabled; + } + /** * Reads the shardsPerCollection parameter in NodeStatsMetric * @@ -166,6 +174,21 @@ public void updateBatchMetricsState(final boolean shouldEnable) { saveStateToConf(this.batchMetricsEnabled, BATCH_METRICS_ENABLED_CONF); } + /** + * Updates the state of the thread contention monitoring api. + * + * @param shouldEnable The desired state of the thread contention monitoring api. False to disable, and true to + * enable. + */ + public void updateThreadContentionMonitoringState(final boolean shouldEnable) { + if (shouldEnable && !isPerformanceAnalyzerEnabled()) { + return; + } + + this.threadContentionMonitoringEnabled = shouldEnable; + saveStateToConf(this.threadContentionMonitoringEnabled, THREAD_CONTENTION_MONITORING_ENABLED_CONF); + } + private void initPerformanceAnalyzerStateFromConf() { Path filePath = Paths.get(getDataDirectory(), PERFORMANCE_ANALYZER_ENABLED_CONF); PerformanceAnalyzerPlugin.invokePrivileged( @@ -249,6 +272,29 @@ private void initBatchMetricsStateFromConf() { }); } + private void initThreadContentionMonitoringStateFromConf() { + Path filePath = Paths.get(getDataDirectory(), THREAD_CONTENTION_MONITORING_ENABLED_CONF); + PerformanceAnalyzerPlugin.invokePrivileged( + () -> { + boolean threadContentionMonitoringEnabledFromConf; + try { + threadContentionMonitoringEnabledFromConf = readBooleanFromFile(filePath); + } catch (NoSuchFileException e) { + LOG.debug("Error reading Performance Analyzer state from Conf file", e); + saveStateToConf( + threadContentionMonitoringEnabledDefaultValue, THREAD_CONTENTION_MONITORING_ENABLED_CONF); + threadContentionMonitoringEnabledFromConf = threadContentionMonitoringEnabledDefaultValue; + } catch (Exception e) { + LOG.debug("Error reading Performance Analyzer state from Conf file", e); + threadContentionMonitoringEnabledFromConf = threadContentionMonitoringEnabledDefaultValue; + } + + // For thread contention monitoring to be enabled, both PA and thread contention monitoring + // need to enabled. + updateThreadContentionMonitoringState(paEnabled && threadContentionMonitoringEnabledFromConf); + }); + } + private boolean readBooleanFromFile(final Path filePath) throws Exception { try (Scanner sc = new Scanner(filePath)) { String nextLine = sc.nextLine(); diff --git a/src/main/java/org/opensearch/performanceanalyzer/config/setting/PerformanceAnalyzerClusterSettings.java b/src/main/java/org/opensearch/performanceanalyzer/config/setting/PerformanceAnalyzerClusterSettings.java index 46bf0291..0cb8bf18 100644 --- a/src/main/java/org/opensearch/performanceanalyzer/config/setting/PerformanceAnalyzerClusterSettings.java +++ b/src/main/java/org/opensearch/performanceanalyzer/config/setting/PerformanceAnalyzerClusterSettings.java @@ -12,7 +12,7 @@ public final class PerformanceAnalyzerClusterSettings { /** * Cluster setting that controls state for various PA components. Bit 0: Perf Analyzer * enabled/disabled Bit 1: RCA enabled/disabled Bit 2: Logging enabled/disabled Bit 3: Batch - * Metrics enabled/disabled + * Metrics enabled/disabled 4: Thread Contention Monitoring enabled/disabled */ public static final Setting COMPOSITE_PA_SETTING = Setting.intSetting( @@ -25,7 +25,8 @@ public enum PerformanceAnalyzerFeatureBits { PA_BIT, RCA_BIT, LOGGING_BIT, - BATCH_METRICS_BIT + BATCH_METRICS_BIT, + THREAD_CONTENTION_MONITORING_BIT } /** diff --git a/src/main/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandler.java b/src/main/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandler.java index f4d4aaf9..52769954 100644 --- a/src/main/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandler.java +++ b/src/main/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandler.java @@ -29,6 +29,9 @@ public class PerformanceAnalyzerClusterSettingHandler implements ClusterSettingL private static final int BATCH_METRICS_ENABLED_BIT_POS = PerformanceAnalyzerClusterSettings.PerformanceAnalyzerFeatureBits.BATCH_METRICS_BIT .ordinal(); + private static final int THREAD_CONTENTION_MONITORING_ENABLED_BIT_POS = + PerformanceAnalyzerClusterSettings.PerformanceAnalyzerFeatureBits.THREAD_CONTENTION_MONITORING_BIT + .ordinal(); private final PerformanceAnalyzerController controller; private final ClusterSettingsManager clusterSettingsManager; @@ -45,7 +48,8 @@ public PerformanceAnalyzerClusterSettingHandler( controller.isPerformanceAnalyzerEnabled(), controller.isRcaEnabled(), controller.isLoggingEnabled(), - controller.isBatchMetricsEnabled()); + controller.isBatchMetricsEnabled(), + controller.isThreadContentionMonitoringEnabled()); } /** @@ -92,6 +96,17 @@ public void updateBatchMetricsSetting(final boolean state) { PerformanceAnalyzerClusterSettings.COMPOSITE_PA_SETTING, settingIntValue); } + /** + * Updates the Thread Contention Monitoring setting across the cluster. + * + * @param state The desired state for Thread Contention Monitoring setting. + */ + public void updateThreadContentionMonitoringSetting(final boolean state) { + final Integer settingIntValue = getThreadContentionMonitoringSettingValueFromState(state); + clusterSettingsManager.updateSetting( + PerformanceAnalyzerClusterSettings.COMPOSITE_PA_SETTING, settingIntValue); + } + /** * Handler that gets called when there is a new value for the setting that this listener is * listening to. @@ -106,6 +121,7 @@ public void onSettingUpdate(final Integer newSettingValue) { controller.updateRcaState(getRcaStateFromSetting(newSettingValue)); controller.updateLoggingState(getLoggingStateFromSetting(newSettingValue)); controller.updateBatchMetricsState(getBatchMetricsStateFromSetting(newSettingValue)); + controller.updateThreadContentionMonitoringState(getThreadContentionMonitoringStateFromSetting(newSettingValue)); } } @@ -130,7 +146,8 @@ private Integer initializeClusterSettingValue( final boolean paEnabled, final boolean rcaEnabled, final boolean loggingEnabled, - final boolean batchMetricsEnabled) { + final boolean batchMetricsEnabled, + final boolean threadContentionMonitoringEnabled) { int clusterSetting = CLUSTER_SETTING_DISABLED_VALUE; clusterSetting = paEnabled ? setBit(clusterSetting, PA_ENABLED_BIT_POS) : clusterSetting; @@ -145,6 +162,10 @@ private Integer initializeClusterSettingValue( batchMetricsEnabled ? setBit(clusterSetting, BATCH_METRICS_ENABLED_BIT_POS) : clusterSetting; + clusterSetting = + threadContentionMonitoringEnabled + ? setBit(clusterSetting, THREAD_CONTENTION_MONITORING_ENABLED_BIT_POS) + : clusterSetting; } return clusterSetting; } @@ -161,10 +182,10 @@ private boolean getPAStateFromSetting(final int settingValue) { /** * Converts the boolean PA state to composite cluster setting. If Performance Analyzer is being - * turned off, it will also turn off RCA, logging, and batch metrics. + * turned off, it will also turn off RCA, logging, batch metrics and thread contention monitoring. * * @param state the state of performance analyzer. Will enable performance analyzer if true, - * disables performance analyzer, RCA, logging, and batch metrics. + * disables performance analyzer, RCA, logging, batch metrics and thread contention monitoring. * @return composite cluster setting as an integer. */ private Integer getPASettingValueFromState(final boolean state) { @@ -176,10 +197,12 @@ private Integer getPASettingValueFromState(final boolean state) { return resetBit( resetBit( resetBit( - resetBit(clusterSetting, PA_ENABLED_BIT_POS), - RCA_ENABLED_BIT_POS), - LOGGING_ENABLED_BIT_POS), - BATCH_METRICS_ENABLED_BIT_POS); + resetBit( + resetBit(clusterSetting, PA_ENABLED_BIT_POS), + RCA_ENABLED_BIT_POS), + LOGGING_ENABLED_BIT_POS), + BATCH_METRICS_ENABLED_BIT_POS), + THREAD_CONTENTION_MONITORING_ENABLED_BIT_POS); } } @@ -213,6 +236,16 @@ private boolean getBatchMetricsStateFromSetting(final int settingValue) { return ((settingValue >> BATCH_METRICS_ENABLED_BIT_POS) & BIT_ONE) == ENABLED_VALUE; } + /** + * Extracts the boolean value for thread contention monitoring state from the cluster setting. + * + * @param settingValue The composite setting value. + * @return true if the THREAD_CONTENTION_MONITORING bit is set, false otherwise. + */ + private boolean getThreadContentionMonitoringStateFromSetting(final int settingValue) { + return ((settingValue >> THREAD_CONTENTION_MONITORING_ENABLED_BIT_POS) & BIT_ONE) == ENABLED_VALUE; + } + /** * Converts the boolean RCA state to composite cluster setting. Enables RCA only if performance * analyzer is also set. Otherwise, results in a no-op. @@ -272,6 +305,26 @@ private Integer getBatchMetricsSettingValueFromState(final boolean shouldEnable) } } + /** + * Converts the boolean thread contention monitoring state to composite cluster setting. Enables thread contention + * monitoring only if performance analyzer is also set. Otherwise, results in a no-op. + * + * @param shouldEnable the state of thread contention monitoring. Will try to enable if true, disables thread + * contention monitoring if false. + * @return composite cluster setting as an integer. + */ + private Integer getThreadContentionMonitoringSettingValueFromState(final boolean shouldEnable) { + int clusterSetting = currentClusterSetting; + + if (shouldEnable) { + return checkBit(currentClusterSetting, PA_ENABLED_BIT_POS) + ? setBit(clusterSetting, THREAD_CONTENTION_MONITORING_ENABLED_BIT_POS) + : clusterSetting; + } else { + return resetBit(clusterSetting, THREAD_CONTENTION_MONITORING_ENABLED_BIT_POS); + } + } + /** * Sets the bit at the specified position. * diff --git a/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigAction.java b/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigAction.java index 155dc6cf..2efc826b 100644 --- a/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigAction.java +++ b/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigAction.java @@ -49,6 +49,8 @@ public class PerformanceAnalyzerClusterConfigAction extends BaseRestHandler { RestConfig.PA_BASE_URI + "/logging/cluster/config"; public static final String BATCH_METRICS_CLUSTER_CONFIG_PATH = RestConfig.PA_BASE_URI + "/batch/cluster/config"; + public static final String THREAD_CONTENTION_MONITORING_CLUSTER_CONFIG_PATH = + RestConfig.PA_BASE_URI + "/threadContentionMonitoring/cluster/config"; public static final String LEGACY_PA_CLUSTER_CONFIG_PATH = RestConfig.LEGACY_PA_BASE_URI + "/cluster/config"; @@ -59,6 +61,16 @@ public class PerformanceAnalyzerClusterConfigAction extends BaseRestHandler { public static final String LEGACY_BATCH_METRICS_CLUSTER_CONFIG_PATH = RestConfig.LEGACY_PA_BASE_URI + "/batch/cluster/config"; + private static final List ROUTES = + unmodifiableList( + asList( + new Route( + RestRequest.Method.GET, + THREAD_CONTENTION_MONITORING_CLUSTER_CONFIG_PATH), + new Route( + RestRequest.Method.POST, + THREAD_CONTENTION_MONITORING_CLUSTER_CONFIG_PATH) + )); private static final List REPLACED_ROUTES = unmodifiableList( asList( @@ -126,7 +138,7 @@ public String getName() { @Override public List routes() { - return Collections.emptyList(); + return ROUTES; } @Override @@ -169,6 +181,8 @@ protected RestChannelConsumer prepareRequest(final RestRequest request, final No } else if (request.path().contains(BATCH_METRICS_CLUSTER_CONFIG_PATH) || request.path().contains(LEGACY_BATCH_METRICS_CLUSTER_CONFIG_PATH)) { clusterSettingHandler.updateBatchMetricsSetting((Boolean) value); + } else if (request.path().contains(THREAD_CONTENTION_MONITORING_CLUSTER_CONFIG_PATH)) { + clusterSettingHandler.updateThreadContentionMonitoringSetting((Boolean) value); } else { clusterSettingHandler.updatePerformanceAnalyzerSetting((Boolean) value); } diff --git a/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigAction.java b/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigAction.java index 4ef24861..c07bd6e8 100644 --- a/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigAction.java +++ b/src/main/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigAction.java @@ -39,6 +39,7 @@ public class PerformanceAnalyzerConfigAction extends BaseRestHandler { public static final String RCA_ENABLED = "rcaEnabled"; public static final String PA_LOGGING_ENABLED = "loggingEnabled"; public static final String BATCH_METRICS_ENABLED = "batchMetricsEnabled"; + public static final String THREAD_CONTENTION_MONITORING_ENABLED = "threadContentionMonitoringEnabled"; public static final String BATCH_METRICS_RETENTION_PERIOD_MINUTES = "batchMetricsRetentionPeriodMinutes"; public static final String PERFORMANCE_ANALYZER_CONFIG_ACTION = @@ -48,6 +49,8 @@ public class PerformanceAnalyzerConfigAction extends BaseRestHandler { public static final String PA_CONFIG_PATH = RestConfig.PA_BASE_URI + "/config"; public static final String LOGGING_CONFIG_PATH = RestConfig.PA_BASE_URI + "/logging/config"; public static final String BATCH_METRICS_CONFIG_PATH = RestConfig.PA_BASE_URI + "/batch/config"; + public static final String THREAD_CONTENTION_MONITORING_CONFIG_PATH = + RestConfig.PA_BASE_URI + "/threadContentionMonitoring/config"; public static final String LEGACY_RCA_CONFIG_PATH = RestConfig.LEGACY_PA_BASE_URI + "/rca/config"; @@ -56,7 +59,16 @@ public class PerformanceAnalyzerConfigAction extends BaseRestHandler { RestConfig.LEGACY_PA_BASE_URI + "/logging/config"; public static final String LEGACY_BATCH_METRICS_CONFIG_PATH = RestConfig.LEGACY_PA_BASE_URI + "/batch/config"; - + private static final List ROUTES = + unmodifiableList( + asList( + new Route( + RestRequest.Method.GET, + THREAD_CONTENTION_MONITORING_CONFIG_PATH), + new Route( + RestRequest.Method.POST, + THREAD_CONTENTION_MONITORING_CONFIG_PATH) + )); private static final List REPLACED_ROUTES = unmodifiableList( asList( @@ -112,7 +124,7 @@ public static void setInstance( @Override public List routes() { - return Collections.emptyList(); + return ROUTES; } @Override @@ -171,6 +183,14 @@ protected RestChannelConsumer prepareRequest(final RestRequest request, final No "Error: PA not enabled. Enable PA before turning Batch Metrics on"); } + performanceAnalyzerController.updateBatchMetricsState(shouldEnable); + } else if (request.path().contains(THREAD_CONTENTION_MONITORING_CONFIG_PATH)) { + if (shouldEnable + && !performanceAnalyzerController.isPerformanceAnalyzerEnabled()) { + return getChannelConsumerWithError( + "Error: PA not enabled. Enable PA before turning Batch Metrics on"); + } + performanceAnalyzerController.updateBatchMetricsState(shouldEnable); } else { // Disabling Performance Analyzer should disable the RCA framework as well. @@ -178,6 +198,7 @@ protected RestChannelConsumer prepareRequest(final RestRequest request, final No performanceAnalyzerController.updateRcaState(false); performanceAnalyzerController.updateLoggingState(false); performanceAnalyzerController.updateBatchMetricsState(false); + performanceAnalyzerController.updateThreadContentionMonitoringState(false); } performanceAnalyzerController.updatePerformanceAnalyzerState(shouldEnable); } @@ -206,6 +227,9 @@ protected RestChannelConsumer prepareRequest(final RestRequest request, final No builder.field( BATCH_METRICS_ENABLED, performanceAnalyzerController.isBatchMetricsEnabled()); + builder.field( + THREAD_CONTENTION_MONITORING_ENABLED, + performanceAnalyzerController.isThreadContentionMonitoringEnabled()); builder.field( BATCH_METRICS_RETENTION_PERIOD_MINUTES, PluginSettings.instance().getBatchMetricsRetentionPeriodMinutes()); diff --git a/src/test/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandlerTests.java b/src/test/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandlerTests.java index 32c82d73..2ecff6e7 100644 --- a/src/test/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandlerTests.java +++ b/src/test/java/org/opensearch/performanceanalyzer/config/setting/handler/PerformanceAnalyzerClusterSettingHandlerTests.java @@ -31,7 +31,7 @@ public void setup() { @Test public void disabledClusterStateTest() { - setControllerValues(DISABLED_STATE, DISABLED_STATE, DISABLED_STATE, DISABLED_STATE); + setControllerValues(DISABLED_STATE, DISABLED_STATE, DISABLED_STATE, DISABLED_STATE,DISABLED_STATE ); clusterSettingHandler = new PerformanceAnalyzerClusterSettingHandler( mockPerformanceAnalyzerController, mockClusterSettingsManager); @@ -40,7 +40,7 @@ public void disabledClusterStateTest() { @Test public void enabledClusterStateTest() { - setControllerValues(ENABLED_STATE, ENABLED_STATE, ENABLED_STATE, ENABLED_STATE); + setControllerValues(ENABLED_STATE, ENABLED_STATE, ENABLED_STATE, ENABLED_STATE, ENABLED_STATE); clusterSettingHandler = new PerformanceAnalyzerClusterSettingHandler( mockPerformanceAnalyzerController, mockClusterSettingsManager); @@ -49,7 +49,7 @@ public void enabledClusterStateTest() { @Test public void paDisabledClusterStateTest() { - setControllerValues(DISABLED_STATE, ENABLED_STATE, ENABLED_STATE, ENABLED_STATE); + setControllerValues(DISABLED_STATE, ENABLED_STATE, ENABLED_STATE, ENABLED_STATE, ENABLED_STATE); clusterSettingHandler = new PerformanceAnalyzerClusterSettingHandler( mockPerformanceAnalyzerController, mockClusterSettingsManager); @@ -58,7 +58,7 @@ public void paDisabledClusterStateTest() { @Test public void updateClusterStateTest() { - setControllerValues(ENABLED_STATE, ENABLED_STATE, DISABLED_STATE, DISABLED_STATE); + setControllerValues(ENABLED_STATE, ENABLED_STATE, DISABLED_STATE, DISABLED_STATE, DISABLED_STATE); clusterSettingHandler = new PerformanceAnalyzerClusterSettingHandler( mockPerformanceAnalyzerController, mockClusterSettingsManager); @@ -71,12 +71,15 @@ private void setControllerValues( final Boolean paEnabled, final Boolean rcaEnabled, final Boolean loggingEnabled, - final Boolean batchMetricsEnabled) { + final Boolean batchMetricsEnabled, + final Boolean threadContentionMonitoringEnabled) { when(mockPerformanceAnalyzerController.isPerformanceAnalyzerEnabled()) .thenReturn(paEnabled); when(mockPerformanceAnalyzerController.isRcaEnabled()).thenReturn(rcaEnabled); when(mockPerformanceAnalyzerController.isLoggingEnabled()).thenReturn(loggingEnabled); when(mockPerformanceAnalyzerController.isBatchMetricsEnabled()) .thenReturn(batchMetricsEnabled); + when(mockPerformanceAnalyzerController.isThreadContentionMonitoringEnabled()) + .thenReturn(threadContentionMonitoringEnabled); } } diff --git a/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigActionTests.java b/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigActionTests.java index 1c2fdf96..50690260 100644 --- a/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigActionTests.java +++ b/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerClusterConfigActionTests.java @@ -144,6 +144,12 @@ public void testLegacyUpdatePerformanceAnalyzerSetting() throws IOException { testWithRequestPath(PerformanceAnalyzerClusterConfigAction.LEGACY_PA_CLUSTER_CONFIG_PATH); } + @Test + public void testUpdateThreadContentionMonitoringSetting() throws IOException { + testWithRequestPath( + PerformanceAnalyzerClusterConfigAction.THREAD_CONTENTION_MONITORING_CLUSTER_CONFIG_PATH); + } + private void testWithRequestPath(String requestPath) throws IOException { final FakeRestRequest fakeRestRequest = buildRequest(requestPath); final FakeRestChannel channel = new FakeRestChannel(fakeRestRequest, true, 10); diff --git a/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigActionTests.java b/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigActionTests.java index ff73af3d..ede4a898 100644 --- a/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigActionTests.java +++ b/src/test/java/org/opensearch/performanceanalyzer/http_action/config/PerformanceAnalyzerConfigActionTests.java @@ -244,6 +244,26 @@ public void testLegacyUpdatePerformanceAnalyzerState_ShouldDisable_paDisabled() test(PerformanceAnalyzerConfigAction.LEGACY_PA_CONFIG_PATH, false, false); } + @Test + public void testUpdateThreadContentionMonitoringState_ShouldEnable_paEnabled() throws IOException { + test(PerformanceAnalyzerConfigAction.THREAD_CONTENTION_MONITORING_CONFIG_PATH, true, true); + } + + @Test + public void testUpdateThreadContentionMonitoringState_ShouldEnable_paDisabled() throws IOException { + test(PerformanceAnalyzerConfigAction.THREAD_CONTENTION_MONITORING_CONFIG_PATH, true, false); + } + + @Test + public void testUpdateThreadContentionMonitoringState_ShouldDisable_paDisabled() throws IOException { + test(PerformanceAnalyzerConfigAction.THREAD_CONTENTION_MONITORING_CONFIG_PATH, false, false); + } + + @Test + public void testUpdateThreadContentionMonitoringState_ShouldDisable_paEnabled() throws IOException { + test(PerformanceAnalyzerConfigAction.THREAD_CONTENTION_MONITORING_CONFIG_PATH, false, true); + } + private void test(String requestPath, boolean shouldEnable, boolean paEnabled) throws IOException { final FakeRestRequest fakeRestRequest = buildRequest(requestPath, shouldEnable); @@ -261,6 +281,7 @@ private void test(String requestPath, boolean shouldEnable, boolean paEnabled) assertTrue(responseStr.contains(PerformanceAnalyzerConfigAction.PA_LOGGING_ENABLED)); assertTrue(responseStr.contains(PerformanceAnalyzerConfigAction.SHARDS_PER_COLLECTION)); assertTrue(responseStr.contains(PerformanceAnalyzerConfigAction.BATCH_METRICS_ENABLED)); + assertTrue(responseStr.contains(PerformanceAnalyzerConfigAction.THREAD_CONTENTION_MONITORING_ENABLED)); assertTrue( responseStr.contains( PerformanceAnalyzerConfigAction