How to use

getEventType

method

in

com.ebay.jetstream.event.JetstreamEvent

public static boolean isMCCounterEvent(JetstreamEvent event) {
  if ((event != null) && event.getEventType().contains(COUNTEREVENT)) {
    return true;
  }
  return false;
}

public static boolean isGroupByCounterEvent(JetstreamEvent event) {
  if ((event != null)
      && event.getEventType().contains(COUNTERGROUPBYEVENT)) {
    return true;
  }
  return false;
}

public static boolean isMCMultiCounterEvent(JetstreamEvent event) {
  if ((event != null) && event.getEventType().contains(MultiCOUNTEREVENT)) {
    return true;
  }
  return false;
}

public boolean isEventSupported(JetstreamEvent event) {
  return eventTypes.contains(event.getEventType());
}

public static boolean isGroupByCounterEventWithTag(JetstreamEvent event,
    Map<String, String> tags) {
  boolean result = false;
  if ((event != null)
      && event.getEventType().contains(COUNTERGROUPBYEVENT)) {
    Set<String> keys = event.keySet();
    String[] keyArray = keys.toArray(new String[0]);
    for (int i = 0; i < keyArray.length; i++) {
      if (keyArray[i].contains(COUNTERGROUPBYEVENTTAG)) {
        result = true;
        if (tags != null) {
          tags.put(keyArray[i],
              String.valueOf(event.get(keyArray[i])));
        }
      }
    }
    if (event.getEventType().contains(COUNTERGROUPBYMETICTIMEEVENT)) {
      tags.put(TAG_METRICTIME,
          String.valueOf(event.get(MCConstant.METRIC_TIME)));
    }
  }
  return result;
}

public Map<String, SessionizationInfo> process(JetstreamEvent event) {
  sessionizationMap.clear();
  eventListener.reset(event);
  esperService.getEPRuntime().sendEvent(event, event.getEventType());
  return sessionizationMap;
}

public void broadcastToSession(MetricWebSocket socket) {
  for(String channel: lastBroadCastbatch.keySet()){
    List<Queue<JetstreamEvent>> eventsList = lastBroadCastbatch.get(channel);
    if(eventsList!=null && eventsList.size() > 0){
      try {
        List<JetstreamEvent> eventsFilteredForSocket = new ArrayList<JetstreamEvent>();
        for (Queue<JetstreamEvent> events : eventsList) {
          for (JetstreamEvent event : events) {
            if(socket.getChannles().contains(event.getEventType())){
              eventsFilteredForSocket.add(event);
            }
          }
        }
        if (eventsFilteredForSocket.size() > 0) {
          String message = JsonUtil.toJson(eventsFilteredForSocket);
          socket.getRemote().sendString(message);
          lastSuccessMessage = message;
        }
        incrementEventSentCounter();
      } catch (IOException e) {
        logger.error(e.getLocalizedMessage(), e);
        registerError(e);
      }
    }
  }
}

public void broadcast(String channel, List<Queue<JetstreamEvent>> eventsList) {
  lastBroadCastbatch.put(channel, eventsList);
  for (MetricWebSocket socket : sockets) {
    try {
      List<JetstreamEvent> eventsFilteredForSocket = new ArrayList<JetstreamEvent>();
      for (Queue<JetstreamEvent> events : eventsList) {
        for (JetstreamEvent event : events) {
          if(socket.getChannles().contains(event.getEventType())){
            eventsFilteredForSocket.add(event);
          }
        }
      }
      if (eventsFilteredForSocket.size() > 0) {
        String message = JsonUtil.toJson(eventsFilteredForSocket);
        socket.getRemote().sendString(message);
        lastSuccessMessage = message;
      }
      incrementEventSentCounter();
    } catch (IOException e) {
      logger.error(e.getLocalizedMessage(), e);
      registerError(e);
    }
  }
}

public void broadcast(String channel, JetstreamEvent event) {
  if (sockets.size() > 0) {
    String message = JsonUtil.toJson(event);
    for (MetricWebSocket socket : sockets) {
      try {
        if(socket.getChannles().contains(event.getEventType())){
          socket.getRemote().sendString(message);
          lastSuccessMessage = message;
          incrementEventSentCounter();
        }
      } catch (IOException e) {
        logger.error(e.getLocalizedMessage(), e);
        registerError(e);
      }
    }
  }
}

@Override
public void sendEvent(JetstreamEvent event) throws EventException {
  incrementEventRecievedCounter();
  String eventType = event.getEventType();

private void processEPL(JetstreamEvent event) {
  Object sesionizerList = event.remove(SessionizerProcessor.SESSIONIZER_LIST);
  try {
    esperService.getEPRuntime().sendEvent(event, event.getEventType());
  } finally {
    if (sesionizerList != null) {
      event.put(SessionizerProcessor.SESSIONIZER_LIST, sesionizerList);
    }
  }
}

if (sessionizer == null) {
  errorManager.registerError("Session profile not configured", ErrorType.Configuration,
      "Session profile not configured for " + event.getEventType());
  return;
if (uid == null) {
  errorManager.registerError("Can not find unique session id", ErrorType.Unexpected,
      "Can not find unique session id, event type is " + event.getEventType());
  return;

if (Constants.EVENT_TYPE_SESSION_EXPIRED_EVENT.equals(firstEvent.getEventType())) {
} else if (Constants.EVENT_TYPE_SESSION_TRANSFERED_EVENT.equals(firstEvent.getEventType())) {
  Session session = (Session) firstEvent.get(Constants.EVENT_PAYLOAD_SESSION_OBJ);
  if (session != null) {

boolean isRawEvent = !interEventTypes.contains(event.getEventType());
String ak = (String) event.get(AFFINITY_KEY);
if (ak == null) {

String metricName = (String) event
    .get(MCConstant.METRIC_NAME);
String columnFamilyName = event.getEventType()
    .toLowerCase();

if (Constants.EVENT_TYPE_SESSION_EXPIRED_EVENT.equals(firstEvent.getEventType())) {
  if (session != null && updateRemoteSession(uid, identifier, session, sessionizer)) {
    session = null;
    return;
} else if (Constants.EVENT_TYPE_SESSION_TRANSFERED_EVENT.equals(firstEvent.getEventType())) {
  if (session == null) {
    session = (Session) firstEvent.get(Constants.EVENT_PAYLOAD_SESSION_OBJ);

private void postMetricFromEvent(JetstreamEvent event) {
  MetricDef metricDef = new MetricDef();
  metricDef.setMetricName((String) event.get(VALIDATION_TYPE));
  Long time = (Long) event.get("timestamp");
  if (currentMaxTime < time) {
    currentMaxTime = time;
  }
  long metricTime = (time / ONE_HOUR) * ONE_HOUR;
  try {
    String groupName = ThreadSafeDateParser.format(new Date(time),
        DATEPATTERN, TIMEZONE);
    metricDef.setMetricGroup(groupName);
  } catch (ParseException e) {
    LOGGER.warn("failed to format date from time:" + time);
  }
  metricDef.setMetricTime(metricTime);
  metricDef.setFrequency(ONE_MINUTE);
  metricDef.setMetricTable(event.getEventType());
  metricDef.setAffinityKey(event.get(affinityKey));
  metricDef.setTopics(event.getForwardingTopics());
  updateMetric(metricDef);
}

metricTables.put(metricName, event.getEventType());

private JetstreamEvent constructTEventHolder(JetstreamEvent event) {
  if (event != null) {
    JetstreamEvent holderEvent = new JetstreamEvent();
    holderEvent.put(JetstreamReservedKeys.JetstreamEventHolder.toString(), event);
    holderEvent.put(JetstreamReservedKeys.EventType.toString(), event.getEventType());
    // insert source application to DTE
    String eventSource = null;
    if (event.get(JetstreamReservedKeys.EventSource.toString()) != null) {
      eventSource = (String) event.get(JetstreamReservedKeys.EventSource.toString());
    }
    else {
      eventSource = JetstreamApplication.getInstance().getApplicationInformation().getApplicationName();
    }
    holderEvent.put(JetstreamReservedKeys.EventSource.toString(), eventSource);
    return holderEvent;
  }
  return event;
}