How to use

getSchema

method

in

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

@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));
          }
        });
  }
}

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);
}

  private static VelocityContext buildAlertContext(PolicyDefinition policyDefinition, AlertStreamEvent event) {
    VelocityContext context = new VelocityContext();
    context.put(AlertContextFields.SITE_ID, event.getSiteId());
    context.put(AlertContextFields.STREAM_ID, event.getStreamId());
    context.put(AlertContextFields.ALERT_ID, event.getAlertId());
    context.put(AlertContextFields.CREATED_BY, event.getCreatedBy());
    context.put(AlertContextFields.CREATED_TIMESTAMP, event.getCreatedTime());
    context.put(AlertContextFields.CREATED_TIME,  String.format("%s %s",
        DateTimeUtil.millisecondsToHumanDateWithSeconds(event.getCreatedTime()),
        DateTimeUtil.CURRENT_TIME_ZONE.getID()));
    context.put(AlertContextFields.ALERT_TIMESTAMP, event.getTimestamp());
    context.put(AlertContextFields.ALERT_TIME,  String.format("%s %s",
        DateTimeUtil.millisecondsToHumanDateWithSeconds(event.getTimestamp()),
        DateTimeUtil.CURRENT_TIME_ZONE.getID()));
    context.put(AlertContextFields.ALERT_SCHEMA, event.getSchema());
    context.put(AlertContextFields.ALERT_EVENT, event);

    context.put(AlertContextFields.POLICY_ID, policyDefinition.getName());
    context.put(AlertContextFields.POLICY_DESC, policyDefinition.getDescription());
    context.put(AlertContextFields.POLICY_TYPE, policyDefinition.getDefinition().getType());
    context.put(AlertContextFields.POLICY_DEFINITION, policyDefinition.getDefinition().getValue());
    context.put(AlertContextFields.POLICY_HANDLER, policyDefinition.getDefinition().getHandlerClass());

    for (Map.Entry<String, Object> entry : event.getDataMap().entrySet()) {
      context.put(entry.getKey(), entry.getValue());
    }
    return context;
  }
}

StreamDefinition streamDefinition = event.getSchema();
HashMap<String, String> customFieldValues = new HashMap<>();
String stateFiledValue = null;

StreamDefinition streamDefinition = outputEvent.getSchema();
for (int i = 0; i < outputEvent.getData().length; i++) {
  if (i > streamDefinition.getColumns().size()) {

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;
}

event.setSchema(originalEvent.getSchema());
event.setPolicyId(originalEvent.getPolicyId());
event.setCreatedTime(originalEvent.getCreatedTime());
event.setCreatedBy(originalEvent.getCreatedBy());
event.setTimestamp(originalEvent.getTimestamp());
StreamDefinition streamDefinition = event.getSchema();
for (int i = 0; i < event.getData().length; i++) {
  String colName = streamDefinition.getColumns().get(i).getName();

@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);
}

@Override
public List<AlertStreamEvent> dedup(AlertStreamEvent event) {
  StreamDefinition streamDefinition = event.getSchema();
  HashMap<String, String> customFieldValues = new HashMap<>();
  String stateFiledValue = null;