How to use

getValue

method

in

rocks.inspectit.server.diagnosis.engine.tag.Tag

/**
 * Returns the InvocationSequenceData of GlobalContext Tag.
 *
 * @param leafTag
 *            leafTag for which the InvocationSequenceData should be returned
 * @return InvocationSequenceData of GlobalContext
 */
private Optional<InvocationSequenceData> getGlobalContext(Tag leafTag) {
  while (null != leafTag) {
    if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_GLOBAL_CONTEXT)) {
      if (leafTag.getValue() instanceof InvocationSequenceData) {
        return Optional.of((InvocationSequenceData) leafTag.getValue());
      } else {
        throw new RuntimeException("Global context has wrong datatype!");
      }
    }
    leafTag = leafTag.getParent();
  }
  return Optional.empty();
}

  /**
   * Returns the CauseStructure of the CauseStructure Tag.
   *
   * @param leafTag
   *            leafTag for which the CauseStructure should be returned
   * @return CauseStructure of leafTag
   */
  private Optional<CauseStructure> getCauseStructure(Tag leafTag) {
    while (null != leafTag) {
      if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_CAUSE_STRUCTURE)) {
        if (leafTag.getValue() instanceof CauseStructure) {
          return Optional.of((CauseStructure) leafTag.getValue());
        } else {
          throw new RuntimeException("Cause structure has wrong datatype!");
        }

      }
      leafTag = leafTag.getParent();
    }

    return Optional.empty();
  }
}

/**
 * Returns the InvocationSequenceData of ProblemContext Tag.
 *
 * @param leafTag
 *            leafTag for which the InvocationSequenceData should be returned
 * @return InvocationSequenceData of ProblemContext
 */
private Optional<CauseCluster> getProblemContext(Tag leafTag) {
  while (null != leafTag) {
    if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_PROBLEM_CONTEXT)) {
      if (leafTag.getValue() instanceof CauseCluster) {
        return Optional.of((CauseCluster) leafTag.getValue());
      } else {
        throw new RuntimeException("Problem context has wrong datatype!");
      }
    }
    leafTag = leafTag.getParent();
  }
  return Optional.empty();
}

/**
 * Returns the AggregatedInvocationSequenceData of RootCauseInvocations Tag.
 *
 * @param leafTag
 *            leafTag for which the AggregatedInvocationSequenceData should be returned
 * @return AggregatedInvocationSequenceData of RootCauseInvocations
 */
private Optional<AggregatedDiagnosisData> getRootCauseInvocations(Tag leafTag) {
  while (null != leafTag) {
    if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_PROBLEM_CAUSE)) {
      if (leafTag.getValue() instanceof AggregatedDiagnosisData) {
        return Optional.of((AggregatedDiagnosisData) leafTag.getValue());
      } else {
        throw new RuntimeException("Problem cause has wrong datatype!");
      }
    }
    leafTag = leafTag.getParent();
  }
  return Optional.empty();
}

@Test
public void validRootTagInput() {
  rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.rootTag("TestInput");
  assertThat(tag.getType(), equalTo(rocks.inspectit.server.diagnosis.engine.tag.Tags.ROOT_TAG));
  assertThat(tag.getValue().toString(), equalTo("TestInput"));
  assertThat(tag.getParent(), equalTo(null));
  assertThat(tag.getState(), equalTo(TagState.LEAF));
}

@Test
public void nullParentTag() {
  Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.tags("A", null, "TestInput1", "TestInput2");
  rocks.inspectit.server.diagnosis.engine.tag.Tag[] tagArray = tags.toArray(new rocks.inspectit.server.diagnosis.engine.tag.Tag[0]);
  assertThat(tags, hasSize(2));
  assertThat(tagArray[0].getType(), equalTo("A"));
  assertThat(tagArray[1].getType(), equalTo("A"));
  assertThat(tagArray[0].getValue().toString(), equalTo("TestInput1"));
  assertThat(tagArray[1].getValue().toString(), equalTo("TestInput2"));
  assertThat(tagArray[0].getParent(), equalTo(null));
  assertThat(tagArray[1].getParent(), equalTo(null));
  assertThat(tagArray[0].getState(), equalTo(TagState.LEAF));
  assertThat(tagArray[1].getState(), equalTo(TagState.LEAF));
}

  @Test
  public void nullRootTagInput() {
    rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.rootTag(null);
    assertThat(tag.getType(), equalTo(rocks.inspectit.server.diagnosis.engine.tag.Tags.ROOT_TAG));
    assertThat(tag.getValue(), equalTo(null));
    assertThat(tag.getParent(), equalTo(null));
    assertThat(tag.getState(), equalTo(TagState.LEAF));
  }
}

@Test
public void nullParentTag() {
  rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput");
  assertThat(tag.getType(), equalTo("A"));
  assertThat(tag.getValue().toString(), equalTo("TestInput"));
  assertThat(tag.getParent(), equalTo(null));
  assertThat(tag.getState(), equalTo(TagState.LEAF));
}

  @Test
  public void withParentTag() {
    rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput");
    assertThat(tagA.getState(), equalTo(TagState.LEAF));
    rocks.inspectit.server.diagnosis.engine.tag.Tag tagB = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "TestInput", tagA);
    assertThat(tagB.getType(), equalTo("B"));
    assertThat(tagB.getValue().toString(), equalTo("TestInput"));
    assertThat(tagB.getParent(), equalTo(tagA));
    assertThat(tagB.getState(), equalTo(TagState.LEAF));
    assertThat(tagA.getState(), equalTo(TagState.PARENT));
  }
}

  @Test
  public void withParentTag() {
    rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput");
    Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.tags("B", tagA, "TestInput1", "TestInput2");
    rocks.inspectit.server.diagnosis.engine.tag.Tag[] tagArray = tags.toArray(new rocks.inspectit.server.diagnosis.engine.tag.Tag[0]);
    assertThat(tags, hasSize(2));
    assertThat(tagArray[0].getType(), equalTo("B"));
    assertThat(tagArray[1].getType(), equalTo("B"));
    assertThat(tagArray[0].getValue().toString(), equalTo("TestInput1"));
    assertThat(tagArray[1].getValue().toString(), equalTo("TestInput2"));
    assertThat(tagArray[0].getParent(), equalTo(tagA));
    assertThat(tagArray[1].getParent(), equalTo(tagA));
    assertThat(tagArray[0].getState(), equalTo(TagState.LEAF));
    assertThat(tagArray[1].getState(), equalTo(TagState.LEAF));
    assertThat(tagA.getState(), equalTo(TagState.PARENT));
  }
}

@Test
public void fromActivated() throws Exception {
  session = new Session<>(Rules.define(RuleA.class, RuleB.class, RuleC.class), new DefaultSessionResultCollector<String>());
  String input = "input";
  session.activate(input, Session.EMPTY_SESSION_VARIABLES);
  DefaultSessionResult<String> result = session.call();
  assertThat(session.getState(), equalTo(State.PROCESSED));
  assertThat(result.getConditionFailures().keys(), empty());
  assertThat(result.getEndTags().keySet(), containsInAnyOrder("C"));
  assertThat(result.getEndTags().get("C"), hasSize(1));
  assertThat(((Integer) result.getEndTags().get("C").iterator().next().getValue()), equalTo((input.length() * 2) + 2));
}

@Test
public void simpleRuleExecution() throws RuleDefinitionException, RuleExecutionException {
  RuleDefinition ruleDefinition = Rules.define(RuleA.class);
  String inputStr = "hallo";
  RuleInput input = new RuleInput(Tags.tag(Tags.ROOT_TAG, inputStr));
  RuleOutput output = ruleDefinition.execute(input, Collections.<String, Object> emptyMap());
  assertThat(output.getRuleName(), equalTo(ruleDefinition.getName()));
  assertThat(output.getTags(), hasSize(1));
  assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStr + inputStr)));
}

@Test
public void ruleWithSessionVariableExecution() throws RuleDefinitionException, RuleExecutionException {
  RuleDefinition ruleDefinition = Rules.define(RuleWithSessionVariable.class);
  String inputStr = "hallo";
  String sessionVar = "sessionVar";
  RuleInput input = new RuleInput(Tags.tag(Tags.ROOT_TAG, inputStr));
  RuleOutput output = ruleDefinition.execute(input, Collections.singletonMap(sessionVar, (Object) sessionVar));
  assertThat(output.getRuleName(), equalTo(ruleDefinition.getName()));
  assertThat(output.getTags(), hasSize(1));
  assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStr + sessionVar)));
}

@Test
public void ruleWithConditionSuccessExecution() throws RuleDefinitionException, RuleExecutionException {
  RuleDefinition ruleDefinition = Rules.define(RuleF.class);
  String inputStrA = "hallo";
  String inputStrE = "again";
  Tag tagA = Tags.tag("A", inputStrA);
  Tag tagE = Tags.tag("E", inputStrE);
  RuleInput inputE = new RuleInput(tagE, Arrays.asList(tagA, tagE));
  RuleOutput output = ruleDefinition.execute(inputE, Collections.<String, Object> emptyMap());
  assertThat(output.getRuleName(), equalTo(ruleDefinition.getName()));
  assertThat(output.getTags(), hasSize(1));
  assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStrA + inputStrE)));
}

/**
 * {@inheritDoc}
 * 
 * @throws RuleExecutionException
 *             If tag injection fails.
 */
@Override
public Object determineValueToInject(ExecutionContext context) throws RuleExecutionException {
  // extract the required type form the unraveled list of input Tags
  for (Tag tag : context.getRuleInput().getUnraveled()) {
    if (tag.getType().equals(getType())) {
      return InjectionStrategy.BY_VALUE.equals(getInjectionStrategy()) ? tag.getValue() : tag;
    }
  }
  throw new RuleExecutionException("Unable to find Tag: " + getType() + " in RuleInput.", context);
}

@Test
public void testEngine() throws DiagnosisEngineException {
  final List<DefaultSessionResult<String>> results = new ArrayList<>();
  final List<Throwable> exceptions = new ArrayList<>();
  DiagnosisEngineConfiguration<String, DefaultSessionResult<String>> configuration = new DiagnosisEngineConfiguration<String, DefaultSessionResult<String>>().setNumSessionWorkers(1)
      .addRuleClasses(RuleA.class, RuleB.class, RuleC.class, RuleE.class).setStorageClass(DefaultRuleOutputStorage.class).setResultCollector(new DefaultSessionResultCollector<String>())
      .addSessionCallback(new ISessionCallback<DefaultSessionResult<String>>() {
        @Override
        public void onSuccess(DefaultSessionResult<String> result) {
          results.add(result);
        }
        @Override
        public void onFailure(Throwable t) {
          exceptions.add(t);
        }
      });
  configuration.setShutdownTimeout(6000);
  DiagnosisEngine<String, DefaultSessionResult<String>> diagnosisEngine = new DiagnosisEngine<>(configuration);
  String input = "Trace";
  diagnosisEngine.analyze(input);
  diagnosisEngine.shutdown(true);
  assertThat(exceptions, empty());
  assertThat(results.get(0).getEndTags().get("C"), hasSize(1));
  assertThat(results.get(0).getEndTags().get("C").iterator().next().getValue(), equalTo((Object) ((input + input).length() + 2)));
  assertThat(results.get(0).getEndTags().get("E"), hasSize(1));
  assertThat(results.get(0).getEndTags().get("E").iterator().next().getValue(), equalTo((Object) (input + "E")));
}