package rocks.inspectit.server.instrumentation.config;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyMap;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import rocks.inspectit.shared.all.instrumentation.config.PriorityEnum;
import rocks.inspectit.shared.all.instrumentation.config.impl.AgentConfig;
import rocks.inspectit.shared.all.instrumentation.config.impl.ExceptionSensorTypeConfig;
import rocks.inspectit.shared.all.instrumentation.config.impl.JmxSensorTypeConfig;
import rocks.inspectit.shared.all.instrumentation.config.impl.MethodSensorTypeConfig;
import rocks.inspectit.shared.all.instrumentation.config.impl.PlatformSensorTypeConfig;
import rocks.inspectit.shared.all.instrumentation.config.impl.RetransformationStrategy;
import rocks.inspectit.shared.all.instrumentation.config.impl.StrategyConfig;
import rocks.inspectit.shared.all.pattern.EqualsMatchPattern;
import rocks.inspectit.shared.all.pattern.IMatchPattern;
import rocks.inspectit.shared.all.pattern.WildcardMatchPattern;
import rocks.inspectit.shared.all.testbase.TestBase;
import rocks.inspectit.shared.cs.ci.Environment;
import rocks.inspectit.shared.cs.ci.exclude.ExcludeRule;
import rocks.inspectit.shared.cs.ci.sensor.exception.IExceptionSensorConfig;
import rocks.inspectit.shared.cs.ci.sensor.jmx.JmxSensorConfig;
import rocks.inspectit.shared.cs.ci.sensor.method.IMethodSensorConfig;
import rocks.inspectit.shared.cs.ci.sensor.method.special.impl.ClassLoadingDelegationSensorConfig;
import rocks.inspectit.shared.cs.ci.sensor.method.special.impl.MBeanServerInterceptorSensorConfig;
import rocks.inspectit.shared.cs.ci.sensor.platform.IPlatformSensorConfig;
import rocks.inspectit.shared.cs.ci.strategy.IStrategyConfig;
import rocks.inspectit.shared.cs.cmr.service.IRegistrationService;
@SuppressWarnings("PMD")
public class ConfigurationCreatorTest extends TestBase {
@InjectMocks
ConfigurationCreator creator;
@Mock
Environment environment;
@Mock
IRegistrationService registrationService;
@Mock
ConfigurationResolver configurationResolver;
@BeforeMethod
public void setup() {
// mock strategies
when(environment.getSendingStrategyConfig()).thenReturn(mock(IStrategyConfig.class));
when(environment.getBufferStrategyConfig()).thenReturn(mock(IStrategyConfig.class));
}
public class EnvironmentToConfiguration extends ConfigurationCreatorTest {
@Test
public void configureAgent() throws Exception {
long agentId = 13L;
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
assertThat(agentConfiguration.getPlatformId(), is(agentId));
verifyNoMoreInteractions(registrationService);
}
@Test
public void configurePlatformSensor() throws Exception {
long agentId = 13L;
long sensorId = 17L;
String className = "className";
Map<String, Object> parameters = Collections.<String, Object> singletonMap("key", "value");
IPlatformSensorConfig platformSensorConfig = mock(IPlatformSensorConfig.class);
when(platformSensorConfig.getClassName()).thenReturn(className);
when(platformSensorConfig.getParameters()).thenReturn(parameters);
when(platformSensorConfig.isActive()).thenReturn(true);
when(environment.getPlatformSensorConfigs()).thenReturn(Collections.singletonList(platformSensorConfig));
when(registrationService.registerPlatformSensorTypeIdent(agentId, className)).thenReturn(sensorId);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<PlatformSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getPlatformSensorTypeConfigs();
assertThat(sensorTypeConfigs, hasSize(1));
PlatformSensorTypeConfig sensorTypeConfig = sensorTypeConfigs.iterator().next();
assertThat(sensorTypeConfig.getId(), is(sensorId));
assertThat(sensorTypeConfig.getClassName(), is(className));
assertThat(sensorTypeConfig.getParameters(), is(parameters));
verify(registrationService, times(1)).registerPlatformSensorTypeIdent(agentId, className);
verifyNoMoreInteractions(registrationService);
}
@Test
public void configurePlatformSensorNotActive() throws Exception {
long agentId = 13L;
IPlatformSensorConfig platformSensorConfig = mock(IPlatformSensorConfig.class);
when(platformSensorConfig.isActive()).thenReturn(false);
when(environment.getPlatformSensorConfigs()).thenReturn(Collections.singletonList(platformSensorConfig));
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<PlatformSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getPlatformSensorTypeConfigs();
assertThat(sensorTypeConfigs, is(empty()));
verifyZeroInteractions(registrationService);
}
@Test
public void configureMethodSensor() throws Exception {
long agentId = 13L;
long sensorId = 17L;
String sensorName = "sensorName";
String className = "className";
Map<String, Object> parameters = Collections.<String, Object> singletonMap("key", "value");
IMethodSensorConfig methodSensorConfig = mock(IMethodSensorConfig.class);
when(methodSensorConfig.getName()).thenReturn(sensorName);
when(methodSensorConfig.getClassName()).thenReturn(className);
when(methodSensorConfig.getParameters()).thenReturn(parameters);
when(methodSensorConfig.getPriority()).thenReturn(PriorityEnum.MAX);
when(environment.getMethodSensorConfigs()).thenReturn(Collections.singletonList(methodSensorConfig));
when(registrationService.registerMethodSensorTypeIdent(agentId, className, parameters)).thenReturn(sensorId);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<MethodSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getMethodSensorTypeConfigs();
assertThat(sensorTypeConfigs, hasSize(1));
MethodSensorTypeConfig sensorTypeConfig = sensorTypeConfigs.iterator().next();
assertThat(sensorTypeConfig.getId(), is(sensorId));
assertThat(sensorTypeConfig.getName(), is(sensorName));
assertThat(sensorTypeConfig.getClassName(), is(className));
assertThat(sensorTypeConfig.getParameters(), is(parameters));
assertThat(sensorTypeConfig.getPriority(), is(PriorityEnum.MAX));
verify(registrationService, times(1)).registerMethodSensorTypeIdent(agentId, className, parameters);
verifyNoMoreInteractions(registrationService);
}
@Test
public void configureExceptionSensor() throws Exception {
long agentId = 13L;
long sensorId = 17L;
String sensorName = "sensorName";
String className = "className";
Map<String, Object> parameters = Collections.<String, Object> singletonMap("key", "value");
IExceptionSensorConfig exceptionSensorConfig = mock(IExceptionSensorConfig.class);
when(exceptionSensorConfig.getName()).thenReturn(sensorName);
when(exceptionSensorConfig.getClassName()).thenReturn(className);
when(exceptionSensorConfig.getParameters()).thenReturn(parameters);
when(environment.getExceptionSensorConfig()).thenReturn(exceptionSensorConfig);
when(registrationService.registerMethodSensorTypeIdent(agentId, className, parameters)).thenReturn(sensorId);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
ExceptionSensorTypeConfig sensorTypeConfig = agentConfiguration.getExceptionSensorTypeConfig();
assertThat(sensorTypeConfig.getId(), is(sensorId));
assertThat(sensorTypeConfig.getName(), is(sensorName));
assertThat(sensorTypeConfig.getClassName(), is(className));
assertThat(sensorTypeConfig.getParameters(), is(parameters));
assertThat(sensorTypeConfig.getPriority(), is(PriorityEnum.NORMAL)); // default priority
verify(registrationService, times(1)).registerMethodSensorTypeIdent(agentId, className, parameters);
verifyNoMoreInteractions(registrationService);
}
@SuppressWarnings("unchecked")
@Test
public void configureJmxSensor() throws Exception {
long agentId = 13L;
long sensorId = 17L;
String className = "className";
Map<String, Object> parameters = Collections.<String, Object> singletonMap("key", "value");
JmxSensorConfig jmxSensorConfig = mock(JmxSensorConfig.class);
when(jmxSensorConfig.getClassName()).thenReturn(className);
when(jmxSensorConfig.getParameters()).thenReturn(parameters);
when(jmxSensorConfig.isActive()).thenReturn(true);
when(environment.getJmxSensorConfig()).thenReturn(jmxSensorConfig);
when(registrationService.registerJmxSensorTypeIdent(agentId, className)).thenReturn(sensorId);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
JmxSensorTypeConfig sensorTypeConfig = agentConfiguration.getJmxSensorTypeConfig();
assertThat(sensorTypeConfig.getId(), is(sensorId));
assertThat(sensorTypeConfig.getClassName(), is(className));
assertThat(sensorTypeConfig.getParameters(), is(parameters));
verify(registrationService, times(1)).registerJmxSensorTypeIdent(agentId, className);
// needed because of the intercepting server sensor
verify(registrationService, times(1)).registerMethodSensorTypeIdent(anyLong(), anyString(), anyMap());
verifyNoMoreInteractions(registrationService);
}
@Test
public void configureJmxSensorNotActive() throws Exception {
long agentId = 13L;
JmxSensorConfig jmxSensorConfig = mock(JmxSensorConfig.class);
when(jmxSensorConfig.isActive()).thenReturn(false);
when(environment.getJmxSensorConfig()).thenReturn(jmxSensorConfig);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
JmxSensorTypeConfig sensorTypeConfig = agentConfiguration.getJmxSensorTypeConfig();
assertThat(sensorTypeConfig, is(nullValue()));
verifyZeroInteractions(registrationService);
}
@Test
public void excludeRules() throws Exception {
ExcludeRule er1 = new ExcludeRule("excludeRule1");
ExcludeRule er2 = new ExcludeRule("wildCard*");
when(configurationResolver.getAllExcludeRules(environment)).thenReturn(Arrays.asList(new ExcludeRule[] { er1, er2 }));
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, 0);
Collection<IMatchPattern> excludeClassesPatterns = agentConfiguration.getExcludeClassesPatterns();
assertThat(excludeClassesPatterns, hasSize(2));
assertThat(excludeClassesPatterns, hasItem(new EqualsMatchPattern(er1.getClassName())));
assertThat(excludeClassesPatterns, hasItem(new WildcardMatchPattern(er2.getClassName())));
}
@Test
public void sendingStrategy() throws Exception {
String className = "className";
Map<String, String> settings = Collections.singletonMap("key", "value");
IStrategyConfig config = mock(IStrategyConfig.class);
when(config.getClassName()).thenReturn(className);
when(config.getSettings()).thenReturn(settings);
when(environment.getSendingStrategyConfig()).thenReturn(config);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, 0);
StrategyConfig strategyConfig = agentConfiguration.getSendingStrategyConfig();
assertThat(strategyConfig.getClazzName(), is(className));
assertThat(strategyConfig.getSettings(), is(settings));
}
@Test
public void bufferStrategy() throws Exception {
String className = "className";
Map<String, String> settings = Collections.singletonMap("key", "value");
IStrategyConfig config = mock(IStrategyConfig.class);
when(config.getClassName()).thenReturn(className);
when(config.getSettings()).thenReturn(settings);
when(environment.getBufferStrategyConfig()).thenReturn(config);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, 0);
StrategyConfig strategyConfig = agentConfiguration.getBufferStrategyConfig();
assertThat(strategyConfig.getClazzName(), is(className));
assertThat(strategyConfig.getSettings(), is(settings));
}
@Test
public void retransformationStrategy() throws Exception {
RetransformationStrategy retransformationStrategy = RetransformationStrategy.ALWAYS;
when(environment.getRetransformationStrategy()).thenReturn(retransformationStrategy);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, 0);
assertThat(agentConfiguration.getRetransformationStrategy(), is(retransformationStrategy));
}
// special method sensor
@Test
public void noSpecialSensors() throws Exception {
long agentId = 13L;
when(environment.isClassLoadingDelegation()).thenReturn(false);
when(environment.getJmxSensorConfig()).thenReturn(null);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<MethodSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getSpecialMethodSensorTypeConfigs();
assertThat(sensorTypeConfigs, is(empty()));
}
@Test
public void classLoadingDelegation() throws Exception {
long agentId = 13L;
long sensorId = 17L;
when(environment.isClassLoadingDelegation()).thenReturn(true);
ClassLoadingDelegationSensorConfig cldConfig = ClassLoadingDelegationSensorConfig.INSTANCE;
when(registrationService.registerMethodSensorTypeIdent(agentId, cldConfig.getClassName(), cldConfig.getParameters())).thenReturn(sensorId);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<MethodSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getSpecialMethodSensorTypeConfigs();
assertThat(sensorTypeConfigs, hasSize(1));
MethodSensorTypeConfig sensorTypeConfig = sensorTypeConfigs.iterator().next();
assertThat(sensorTypeConfig.getId(), is(sensorId));
assertThat(sensorTypeConfig.getName(), is(cldConfig.getName()));
assertThat(sensorTypeConfig.getClassName(), is(cldConfig.getClassName()));
assertThat(sensorTypeConfig.getParameters(), is(cldConfig.getParameters()));
assertThat(sensorTypeConfig.getPriority(), is(cldConfig.getPriority()));
verify(registrationService, times(1)).registerMethodSensorTypeIdent(agentId, cldConfig.getClassName(), cldConfig.getParameters());
verifyNoMoreInteractions(registrationService);
}
@Test
public void mbeanServerInterceptor() throws Exception {
long agentId = 13L;
long sensorId = 17L;
JmxSensorConfig jmxSensorConfig = mock(JmxSensorConfig.class);
when(jmxSensorConfig.isActive()).thenReturn(true);
when(environment.getJmxSensorConfig()).thenReturn(jmxSensorConfig);
MBeanServerInterceptorSensorConfig msiConfig = MBeanServerInterceptorSensorConfig.INSTANCE;
when(registrationService.registerMethodSensorTypeIdent(agentId, msiConfig.getClassName(), msiConfig.getParameters())).thenReturn(sensorId);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<MethodSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getSpecialMethodSensorTypeConfigs();
assertThat(sensorTypeConfigs, hasSize(1));
MethodSensorTypeConfig sensorTypeConfig = sensorTypeConfigs.iterator().next();
assertThat(sensorTypeConfig.getId(), is(sensorId));
assertThat(sensorTypeConfig.getName(), is(msiConfig.getName()));
assertThat(sensorTypeConfig.getClassName(), is(msiConfig.getClassName()));
assertThat(sensorTypeConfig.getParameters(), is(msiConfig.getParameters()));
assertThat(sensorTypeConfig.getPriority(), is(msiConfig.getPriority()));
verify(registrationService, times(1)).registerMethodSensorTypeIdent(agentId, msiConfig.getClassName(), msiConfig.getParameters());
// needed because jmx sensor will be also registered
verify(registrationService, times(1)).registerJmxSensorTypeIdent(anyLong(), anyString());
verifyNoMoreInteractions(registrationService);
}
@Test
public void mbeanServerInterceptorJmxNotActive() throws Exception {
long agentId = 13L;
JmxSensorConfig jmxSensorConfig = mock(JmxSensorConfig.class);
when(jmxSensorConfig.isActive()).thenReturn(false);
when(environment.getJmxSensorConfig()).thenReturn(jmxSensorConfig);
AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
Collection<MethodSensorTypeConfig> sensorTypeConfigs = agentConfiguration.getSpecialMethodSensorTypeConfigs();
assertThat(sensorTypeConfigs, is(empty()));
verifyZeroInteractions(registrationService);
}
}
}