congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
ConfigurationResolver.getInstrumentationAppliers
Code IndexAdd Tabnine to your IDE (free)

How to use
getInstrumentationAppliers
method
in
rocks.inspectit.server.instrumentation.config.ConfigurationResolver

Best Java code snippets using rocks.inspectit.server.instrumentation.config.ConfigurationResolver.getInstrumentationAppliers (Showing top 13 results out of 315)

origin: inspectIT/inspectIT

@Test
public void nullEnvironment() {
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(null);
  assertThat(appliers, is(empty()));
  verifyZeroInteractions(functionalAssignmentFactory, configurationInterfaceManager);
}
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

@Test
public void noProfile() {
  when(environment.getProfileIds()).thenReturn(Collections.<String> emptySet());
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void specialAssignments() {
  SpecialMethodSensorAssignment assignment = mock(SpecialMethodSensorAssignment.class);
  when(functionalAssignmentFactory.getSpecialAssignments(environment)).thenReturn(Collections.singletonList(assignment));
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(SpecialInstrumentationApplier.class)));
  assertThat((SpecialMethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void profileDoesNotExists() throws BusinessException {
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenThrow(new BusinessException(null));
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void methodSensorAssignment() throws BusinessException {
  MethodSensorAssignment assignment = mock(MethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(MethodSensorInstrumentationApplier.class)));
  assertThat((MethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void profileNotActive() throws BusinessException {
  MethodSensorAssignment assignment = mock(MethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(false);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
  verifyZeroInteractions(assignment);
}
origin: inspectIT/inspectIT

@Test
public void wrongProfileData() throws BusinessException {
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(new ExcludeRulesProfileData()).when(profile).getProfileData();
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, is(empty()));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void invocationStartsSensorAssignment() throws BusinessException {
  InvocationStartMethodSensorAssignment assignment = mock(InvocationStartMethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(InvocationStartMethodSensorInstrumentationApplier.class)));
  assertThat((InvocationStartMethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void timerSensorAssignment() throws BusinessException {
  TimerMethodSensorAssignment assignment = mock(TimerMethodSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(TimerMethodSensorInstrumentationApplier.class)));
  assertThat((TimerMethodSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
origin: inspectIT/inspectIT

@Test
public void exceptionSensorAssignment() throws BusinessException {
  ExceptionSensorAssignment assignment = mock(ExceptionSensorAssignment.class);
  when(environment.getProfileIds()).thenReturn(Collections.singleton(PROFILE_ID));
  when(configurationInterfaceManager.getProfile(PROFILE_ID)).thenReturn(profile);
  doReturn(sensorAssignmentProfileData).when(profile).getProfileData();
  doReturn(Collections.singletonList(assignment)).when(sensorAssignmentProfileData).getData(SensorAssignmentProfileData.class);
  when(profile.isActive()).thenReturn(true);
  Collection<IInstrumentationApplier> appliers = configurationResolver.getInstrumentationAppliers(environment);
  assertThat(appliers, hasSize(1));
  IInstrumentationApplier applier = appliers.iterator().next();
  assertThat(applier, is(instanceOf(ExceptionSensorInstrumentationApplier.class)));
  assertThat((ExceptionSensorAssignment) applier.getSensorAssignment(), is(assignment));
  verify(functionalAssignmentFactory).getSpecialAssignments(environment);
}
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 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);
}
rocks.inspectit.server.instrumentation.configConfigurationResolvergetInstrumentationAppliers

Javadoc

Returns all instrumentation appliers for one environment.

Popular methods of ConfigurationResolver

  • getAllExcludeRules
    Returns all ExcludeRules contained in all profiles for the given environment.
  • getEnvironmentForAgent
    Tries to locate one Environment for the given agent name and IPs. If only one Environment fits the a
  • getInstrumentationApplier
    Returns the IInstrumentationApplier for the given sensor assignment and the Environment it's being u
  • getJmxMonitoringAppliers
    Returns all JMX monitoring appliers for one environment.
  • getConfigurationInfo
    Returns the configuration info based on the given Environment.
  • matches
    Checks if the specified AgentMapping is matching the agent name and IPs.

Popular in Java

  • Start an intent from android
  • onRequestPermissionsResult (Fragment)
  • setScale (BigDecimal)
  • addToBackStack (FragmentTransaction)
  • System (java.lang)
    Provides access to system-related information and resources including standard input and output. Ena
  • DateFormat (java.text)
    Formats or parses dates and times.This class provides factories for obtaining instances configured f
  • NumberFormat (java.text)
    The abstract base class for all number formats. This class provides the interface for formatting and
  • Collection (java.util)
    Collection is the root of the collection hierarchy. It defines operations on data collections and t
  • Stack (java.util)
    Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables u
  • Timer (java.util)
    Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
  • Github Copilot alternatives
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