Tabnine Logo
ConfigurationCreator
Code IndexAdd Tabnine to your IDE (free)

How to use
ConfigurationCreator
in
rocks.inspectit.server.instrumentation.config

Best Java code snippets using rocks.inspectit.server.instrumentation.config.ConfigurationCreator (Showing top 19 results out of 315)

origin: inspectIT/inspectIT

/**
 * Updates the defined configuration in the holder with following tasks:<br>
 * 1. Creates the new {@link #agentConfiguration} for given environment and platform id<br>
 * 2. Resolves all {@link #instrumentationAppliers} for given environment<br>
 * 3. sets the passes environment to the holder.
 * <p>
 * If <code>null</code> is passed then everything saved in the holder will be reset to
 * <code>null</code> as well.
 *
 * @param environment
 *            Environment to update the configuration and appliers with.
 * @param platformId
 *            Agent id needed for resolving configuration.
 */
public void update(Environment environment, long platformId) {
  if (null != environment) {
    this.environment = environment;
    this.agentConfiguration = configurationCreator.environmentToConfiguration(environment, platformId);
    this.instrumentationAppliers = configurationResolver.getInstrumentationAppliers(environment);
    this.jmxMonitoringAppliers = configurationResolver.getJmxMonitoringAppliers(environment);
  } else {
    this.environment = null; // NOPMD
    this.agentConfiguration = null; // NOPMD
    this.instrumentationAppliers = null; // NOPMD
    this.jmxMonitoringAppliers = null; // NOPMD
  }
}
origin: inspectIT/inspectIT

  for (IPlatformSensorConfig platformSensorConfig : environment.getPlatformSensorConfigs()) {
    if (platformSensorConfig.isActive()) {
      platformSensorTypeConfigs.add(getPlatformSensorTypeConfig(platformId, platformSensorConfig));
  Collection<MethodSensorTypeConfig> methodSensorTypeConfigs = new ArrayList<>();
  for (IMethodSensorConfig methodSensorConfig : environment.getMethodSensorConfigs()) {
    methodSensorTypeConfigs.add(getMethodSensorTypeConfig(platformId, methodSensorConfig));
  agentConfiguration.setExceptionSensorTypeConfig(getExceptionSensorTypeConfig(platformId, exceptionSensorConfig));
  agentConfiguration.setJmxSensorTypeConfig(getJmxSensorTypeConfig(platformId, jmxSensorConfig));
  specialMethodSensorTypeConfigs.add(getMethodSensorTypeConfig(platformId, ClassLoadingDelegationSensorConfig.INSTANCE));
  specialMethodSensorTypeConfigs.add(getMethodSensorTypeConfig(platformId, MBeanServerInterceptorSensorConfig.INSTANCE));
  specialMethodSensorTypeConfigs.add(getMethodSensorTypeConfig(platformId, EUMInstrumentationSensorConfig.INSTANCE));
specialMethodSensorTypeConfigs.add(getMethodSensorTypeConfig(platformId, ExecutorIntercepterSensorConfig.INSTANCE));
specialMethodSensorTypeConfigs.add(getMethodSensorTypeConfig(platformId, CloseableHttpAsyncClientSensorConfig.INSTANCE));
origin: inspectIT/inspectIT

@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));
}
origin: inspectIT/inspectIT

@Test
public void disruptorStrategy() 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.getDisruptorStrategyConfig()).thenReturn(config);
  AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, 0);
  StrategyConfig strategyConfig = agentConfiguration.getDisruptorStrategyConfig();
  assertThat(strategyConfig.getClassName(), is(className));
  assertThat(strategyConfig.getSettings(), is(settings));
}
origin: inspectIT/inspectIT

  @Test
  public void updateReset() {
    long platformId = 11;
    Environment environment = mock(Environment.class);
    AgentConfig configuration = mock(AgentConfig.class);
    IInstrumentationApplier applier = mock(IInstrumentationApplier.class);
    JmxMonitoringApplier jmxApplier = mock(JmxMonitoringApplier.class);
    when(configurationCreator.environmentToConfiguration(environment, platformId)).thenReturn(configuration);
    when(configurationResolver.getInstrumentationAppliers(environment)).thenReturn(Collections.singleton(applier));
    when(configurationResolver.getJmxMonitoringAppliers(environment)).thenReturn(Collections.singleton(jmxApplier));
    holder.update(environment, platformId);
    holder.update(null, platformId);
    assertThat(holder.isInitialized(), is(false));
    // only one time verifications
    verify(configurationCreator).environmentToConfiguration(environment, platformId);
    verify(configurationResolver).getInstrumentationAppliers(environment);
    verify(configurationResolver).getJmxMonitoringAppliers(environment);
    verifyNoMoreInteractions(configurationCreator, configurationResolver);
  }
}
origin: inspectIT/inspectIT

@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(Iterators.get(sensorTypeConfigs.iterator(), 0).getClassName(), is(equalTo(eisc.getClassName())));
  assertThat(Iterators.get(sensorTypeConfigs.iterator(), 1).getClassName(), is(equalTo(closeableHttpAsyncCLient.getClassName())));
}
origin: inspectIT/inspectIT

@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())));
}
origin: inspectIT/inspectIT

@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()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@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()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@Test
public void configureAgent() throws Exception {
  long agentId = 13L;
  AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, agentId);
  assertThat(agentConfiguration.getPlatformId(), is(agentId));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@Test
public void eumConfig() throws Exception {
  EndUserMonitoringConfig config = mock(EndUserMonitoringConfig.class);
  when(config.isEumEnabled()).thenReturn(true);
  String url = "/base/url";
  when(config.getScriptBaseUrl()).thenReturn(url);
  String modules = "12a";
  when(config.getActiveModules()).thenReturn(modules);
  when(config.isListenerInstrumentationAllowed()).thenReturn(false);
  when(config.isAgentMinificationEnabled()).thenReturn(false);
  when(environment.getEumConfig()).thenReturn(config);
  AgentConfig agentConfiguration = creator.environmentToConfiguration(environment, 0);
  AgentEndUserMonitoringConfig eumConfig = agentConfiguration.getEumConfig();
  assertThat(eumConfig.isEnabled(), is(true));
  assertThat(eumConfig.getActiveModules(), is(modules));
  assertThat(eumConfig.getScriptBaseUrl(), is(url));
  assertThat(eumConfig.isListenerInstrumentationAllowed(), is(false));
  assertThat(eumConfig.isAgentMinificationEnabled(), is(false));
}
origin: inspectIT/inspectIT

  @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, hasSize(2));
    assertThat(sensorTypeConfigs.iterator().next().getClassName(), is(equalTo(eisc.getClassName())));
    verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
    verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
    verifyNoMoreInteractions(registrationService);
  }
}
origin: inspectIT/inspectIT

@Test
public void update() {
  long platformId = 11;
  Environment environment = mock(Environment.class);
  AgentConfig configuration = mock(AgentConfig.class);
  IInstrumentationApplier applier = mock(IInstrumentationApplier.class);
  JmxMonitoringApplier jmxApplier = mock(JmxMonitoringApplier.class);
  when(configurationCreator.environmentToConfiguration(environment, platformId)).thenReturn(configuration);
  when(configurationResolver.getInstrumentationAppliers(environment)).thenReturn(Collections.singleton(applier));
  when(configurationResolver.getJmxMonitoringAppliers(environment)).thenReturn(Collections.singleton(jmxApplier));
  holder.update(environment, platformId);
  assertThat(holder.isInitialized(), is(true));
  assertThat(holder.getEnvironment(), is(environment));
  assertThat(holder.getAgentConfiguration(), is(configuration));
  assertThat(holder.getInstrumentationAppliers(), hasSize(1));
  assertThat(holder.getInstrumentationAppliers(), hasItem(applier));
  assertThat(holder.getJmxMonitoringAppliers(), hasSize(1));
  assertThat(holder.getJmxMonitoringAppliers(), hasItem(jmxApplier));
  verify(configurationCreator).environmentToConfiguration(environment, platformId);
  verify(configurationResolver).getInstrumentationAppliers(environment);
  verify(configurationResolver).getJmxMonitoringAppliers(environment);
  verifyNoMoreInteractions(configurationCreator, configurationResolver);
}
origin: inspectIT/inspectIT

@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).registerJmxSensorTypeIdent(agentId, className);
  // needed because of the intercepting server sensor
  verify(registrationService, times(3)).registerMethodSensorTypeIdent(anyLong(), anyString(), anyMap());
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@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).registerMethodSensorTypeIdent(agentId, className, parameters);
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@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).registerPlatformSensorTypeIdent(agentId, className);
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@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).registerMethodSensorTypeIdent(agentId, className, parameters);
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@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(3));
  // first element will be class loading config
  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).registerMethodSensorTypeIdent(agentId, cldConfig.getClassName(), cldConfig.getParameters());
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
origin: inspectIT/inspectIT

@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(3));
  // first element will be mbean server interceptor config
  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).registerMethodSensorTypeIdent(agentId, msiConfig.getClassName(), msiConfig.getParameters());
  // needed because jmx sensor will be also registered
  verify(registrationService).registerJmxSensorTypeIdent(anyLong(), anyString());
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(eisc.getClassName()), eq(eisc.getParameters()));
  verify(registrationService).registerMethodSensorTypeIdent(anyLong(), eq(closeableHttpAsyncCLient.getClassName()), eq(closeableHttpAsyncCLient.getParameters()));
  verifyNoMoreInteractions(registrationService);
}
rocks.inspectit.server.instrumentation.configConfigurationCreator

Javadoc

Configuration creator is responsible for creating the AgentConfig from the Environment.

Most used methods

  • environmentToConfiguration
    Returns proper configuration for the agent with the correctly set IDs for the agent and sensors.
  • getExceptionSensorTypeConfig
    Creates the agent based ExceptionSensorTypeConfig with correctly registered ID.
  • getJmxSensorTypeConfig
    Creates the agent based JmxAttributeDescriptor with correctly registered ID.
  • getMethodSensorTypeConfig
    Creates the agent based MethodSensorTypeConfig with correctly registered ID.
  • getPlatformSensorTypeConfig
    Creates the agent based PlatformSensorTypeConfig with correctly registered ID.

Popular in Java

  • Creating JSON documents from java classes using gson
  • onCreateOptionsMenu (Activity)
  • setContentView (Activity)
  • setScale (BigDecimal)
  • SQLException (java.sql)
    An exception that indicates a failed JDBC operation. It provides the following information about pro
  • DecimalFormat (java.text)
    A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features desig
  • NumberFormat (java.text)
    The abstract base class for all number formats. This class provides the interface for formatting and
  • Stack (java.util)
    Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables u
  • Collectors (java.util.stream)
  • JButton (javax.swing)
  • Top 12 Jupyter Notebook extensions
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now