How to use

getData

method

in

org.apache.eagle.alert.engine.model.AlertStreamEvent

  @Override
  public void emit(Object o) {
    AlertStreamEvent e = (AlertStreamEvent) o;
    Object[] data = e.getData();
    LOG.info("alert data: {}, {}", data[1], data[0]);
  }
}

@Override
public String toString() {
  List<String> dataStrings = new ArrayList<>(this.getData().length);
  for (Object obj : this.getData()) {
    if (obj != null) {
      dataStrings.add(obj.toString());
    } else {
      dataStrings.add(null);
    }
  }
  return String.format("Alert {site=%s, stream=%s,timestamp=%s,data=%s, policyId=%s, createdBy=%s, metaVersion=%s}",
    this.getSiteId(),
    this.getStreamId(), DateTimeUtil.millisecondsToHumanDateWithMilliseconds(this.getTimestamp()),
    this.getDataMap(), this.getPolicyId(), this.getCreatedBy(), this.getMetaVersion());
}

public String streamEventToJson(AlertStreamEvent event) {
  Map<String, Object> jsonMap = new HashMap<String, Object>();
  jsonMap.put("policyId", event.getPolicyId());
  jsonMap.put("streamId", event.getStreamId());
  jsonMap.put("createBy", event.getCreatedBy());
  jsonMap.put("createTime", event.getCreatedTime());
  // data
  int size = event.getData().length;
  List<StreamColumn> columns = event.getSchema().getColumns();
  for (int i = 0; i < size; i++) {
    if (columns.size() < i) {
      // redundant check to log inconsistency
      LOG.error(" stream event data have different lenght compare to column definition! ");
    } else {
      jsonMap.put(columns.get(i).getName(), event.getData()[i]);
    }
  }
  return JsonUtils.writeValueAsString(jsonMap);
}

public Map<String, Object> getDataMap() {
  Map<String, Object> event = new HashMap<>();
  for (StreamColumn column : schema.getColumns()) {
    Object obj = this.getData()[schema.getColumnIndex(column.getName())];
    if (obj == null) {
      event.put(column.getName(), null);
      continue;
    }
    event.put(column.getName(), obj);
  }
  return event;
}

for (int i = 0; i < outputEvent.getData().length; i++) {
  if (i > streamDefinition.getColumns().size()) {
    if (LOG.isWarnEnabled()) {
    severity = outputEvent.getData()[i].toString();
    publishToSlack = severitys.contains(severity);
    message = outputEvent.getData()[i].toString();

private AlertStreamEvent mergeEventWithDedupValue(AlertStreamEvent originalEvent,
                         DedupValue dedupValue, String dedupStateField) {
  AlertStreamEvent event = new AlertStreamEvent();
  Object[] newdata = new Object[originalEvent.getData().length];
  for (int i = 0; i < originalEvent.getData().length; i++) {
    newdata[i] = originalEvent.getData()[i];
  event.setTimestamp(originalEvent.getTimestamp());
  StreamDefinition streamDefinition = event.getSchema();
  for (int i = 0; i < event.getData().length; i++) {
    String colName = streamDefinition.getColumns().get(i).getName();
    if (Objects.equal(colName, dedupStateField)) {
      event.getData()[i] = dedupValue.getStateFieldValue();
      event.getData()[i] = dedupValue.getCount();
      event.getData()[i] = dedupValue.getFirstOccurrence();
      event.getData()[i] = dedupValue.getDocId();

HashMap<String, String> customFieldValues = new HashMap<>();
String stateFiledValue = null;
for (int i = 0; i < event.getData().length; i++) {
  if (i > streamDefinition.getColumns().size()) {
    if (LOG.isWarnEnabled()) {
  Object colValue = event.getData()[i];

  @Override
  public void emit(Object o) {
    AlertStreamEvent e = (AlertStreamEvent) o;
    Object[] data = e.getData();
    Assert.assertEquals("host2", data[1]);
    LOG.info(e.toString());
  }
}

  @Override
  public void emit(Object o) {
    AlertStreamEvent e = (AlertStreamEvent) o;
    Object[] data = e.getData();
    Assert.assertEquals("host2", data[1]);
    LOG.info(e.toString());
  }
}

@Override
public void emit(AlertStreamEvent event) {
  if (event == null) {
    return;
  }
  event.ensureAlertId();
  Set<PublishPartition> clonedPublishPartitions = new HashSet<>(publishPartitions);
  for (PublishPartition publishPartition : clonedPublishPartitions) {
    // skip the publish partition which is not belong to this policy and also check streamId
    PublishPartition cloned = publishPartition.clone();
    Optional.ofNullable(event)
        .filter(x -> x != null
            && x.getSchema() != null
            && cloned.getPolicyId().equalsIgnoreCase(x.getPolicyId())
            && (cloned.getStreamId().equalsIgnoreCase(x.getSchema().getStreamId())
            || cloned.getStreamId().equalsIgnoreCase(Publishment.STREAM_NAME_DEFAULT)))
        .ifPresent(x -> {
          cloned.getColumns().stream()
              .filter(y -> event.getSchema().getColumnIndex(y) >= 0
                  && event.getSchema().getColumnIndex(y) < event.getSchema().getColumns().size())
              .map(y -> event.getData()[event.getSchema().getColumnIndex(y)])
              .filter(y -> y != null)
              .forEach(y -> cloned.getColumnValues().add(y));
          synchronized (outputLock) {
            streamContext.counter().incr("alert_count");
            delegate.emit(Arrays.asList(cloned, event));
          }
        });
  }
}

private DedupValue createDedupValue(EventUniq eventEniq, AlertStreamEvent event, String stateFieldValue) {
  DedupValue dedupValue;
  dedupValue = new DedupValue();
  dedupValue.setFirstOccurrence(eventEniq.timestamp);
  int idx = event.getSchema().getColumnIndex(DOC_ID);
  if (idx >= 0) {
    dedupValue.setDocId(event.getData()[idx].toString());
  } else {
    dedupValue.setDocId("");
  }
  dedupValue.setCount(1);
  dedupValue.setCloseTime(0);
  dedupValue.setStateFieldValue(stateFieldValue);
  return dedupValue;
}

HashMap<String, String> customFieldValues = new HashMap<>();
String stateFiledValue = null;
for (int i = 0; i < event.getData().length; i++) {
  if (i > streamDefinition.getColumns().size()) {
    continue;
    stateFiledValue = event.getData()[i].toString();
    customFieldValues.put(colName, event.getData()[i].toString());
  } else {
    for (String field : this.getCustomDedupFields()) {
      if (colName.equals(field)) {
        customFieldValues.put(field, event.getData()[i].toString());
        break;

Assert.assertNotNull(event.getData()[4]);
Assert.assertNotNull(event.getData()[5]);
if (((Long) event.getData()[4]) > maxCount) {
  maxCount = (Long) event.getData()[4];
  System.out.println(String.format(">>>>>%s: %s", event, maxCount));

@Test
public void testNormal() throws Exception {
  Config config = ConfigFactory.load();
  DedupCache dedupCache = new DedupCache(config, "testPublishment");
  StreamDefinition stream = createStream();
  PolicyDefinition policy = createPolicy(stream.getStreamId(), "testPolicy");
  String[] states = new String[] {"OPEN", "WARN", "CLOSE"};
  Random random = new Random();
  for (int i = 0; i < 20; i++) {
    AlertStreamEvent event = createEvent(stream, policy, new Object[] {
      System.currentTimeMillis(), "host1", "testPolicy-host1-01", states[random.nextInt(3)], 0, 0
    });
    HashMap<String, String> dedupFieldValues = new HashMap<String, String>();
    dedupFieldValues.put("alertKey", (String) event.getData()[event.getSchema().getColumnIndex("alertKey")]);
    List<AlertStreamEvent> result = dedupCache.dedup(event,
      new EventUniq(event.getStreamId(), event.getPolicyId(), event.getCreatedTime(), dedupFieldValues),
      "state",
      (String) event.getData()[event.getSchema().getColumnIndex("state")], "closed");
    System.out.println((i + 1) + " >>>> " + ToStringBuilder.reflectionToString(result));
  }
  Assert.assertTrue(true);
}

Assert.assertEquals(1, alerts.size());
Assert.assertEquals("joinedStream", alerts.get(0).getStreamId());
Assert.assertEquals("cpu", alerts.get(0).getData()[1]);