How to use

JetstreamEvent

in

com.ebay.jetstream.event

if (!event.containsKey(Constants.REPLAY_INITIAL_TS)) {
  event.addMetaData(Constants.REPLAY_INITIAL_TS, current);
  event.addMetaData(Constants.REPLAY_LAST_TS, current);
} else if (event.containsKey(Constants.REPLAY_LAST_TS)) {
  long initTs = (Long) event.get(Constants.REPLAY_INITIAL_TS);
    return;
  event.addMetaData(Constants.REPLAY_INITIAL_TS, initTs);
  event.addMetaData(Constants.REPLAY_LAST_TS, current);
  event.remove(Constants.REPLAY_INITIAL_TS);
  event.remove(Constants.REPLAY_LAST_TS);
if (event.containsKey(JetstreamReservedKeys.RetryCount.toString())) {
  event.put(JetstreamReservedKeys.RetryCount.toString(), 0);
if (event.containsKey(getReplayConfig().getTimestampKey())) {
  event.remove(getReplayConfig().getTimestampKey());
    .toString();
if (replayTopicKey != null && event.containsKey(replayTopicKey)) {
  event.remove(replayTopicKey);
event.put(REPLAY_TAG, Boolean.TRUE);
event.setForwardingTopics(null);
super.fireSendEvent(event);

@Override
public void sendExpirationCheckEvent(String uid, String ak) {
  JetstreamEvent jsEvent = new JetstreamEvent();
  int type = identifierType(uid);
  jsEvent.setEventType(Constants.EVENT_TYPE_SESSION_EXPIRED_EVENT);
  jsEvent.put(Constants.EVENT_PAYLOAD_SESSION_UNIQUEID, uid);
  jsEvent.put(Constants.EVENT_PAYLOAD_SESSION_TYPE, Integer.valueOf(type));
  jsEvent.put(AFFINITY_KEY, ak);
  this.loopbackEventProducer.sendExpirationCheckEvent(jsEvent);
}

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

private JetstreamEvent createEvent(Map<String, Object> data, String eventType) {
  JetstreamEvent event = new JetstreamEvent(data);
  event.setEventType(eventType);
  return event;
}

private void sessionBegin(Session session) {
  JetstreamEvent sessionBeginEvent = new JetstreamEvent();
  sessionBeginEvent.setEventType(mainSessionProfile.getBeginMarker());
  Map<String, Object> initialAttributes = session.getInitialAttributes();
  if (initialAttributes != null) {
    sessionBeginEvent.putAll(initialAttributes);
  }
  if (mainSessionProfile.getSessionIdKey() != null) {
    sessionBeginEvent.put(mainSessionProfile.getSessionIdKey(), session.getSessionId());
  }
  if (mainSessionProfile.getSessionStartTimestampKey() != null) {
    sessionBeginEvent.put(mainSessionProfile.getSessionStartTimestampKey(), session.getCreationTime());
  }
  if (mainEsperSessionizer != null && mainEsperSessionizer.isEventSupported(sessionBeginEvent)) {
    mainEsperSessionizer.process(session, sessionBeginEvent);
  }
  eventSender.sendSessionBeginEvent(mainSessionProfile.getSessionType(), session, sessionBeginEvent);
}

private void execute(BoundStatement q, JetstreamEvent event) {
  try {
    ResultSetFuture future = cassandraSession.executeAsync(q);
    CallBackListener listener = new CallBackListener(future, event);
    future.addListener(listener, pool);
    pendingRequestCounter.incrementAndGet();
  } catch (Throwable ex) {
    LOGGER.error(
        "Error publising metrics in MetricCassandraCollector:"
            + ex.getMessage());
    cassandraErrorCount.increment();
    if (event.get(JetstreamReservedKeys.MessageAffinityKey.toString()) == null) {
      event.put(JetstreamReservedKeys.MessageAffinityKey.toString(),
          (String) event.get(MCConstant.METRIC_NAME));
    }
    getAdviceListener().retry(event, RetryEventCode.MSG_RETRY,
        ex.getMessage());
    eventSentToAdviceListener.increment();
    registerError(ex);
  }
}

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

  @Override
  public void sendEvent(JetstreamEvent event) throws EventException {
    String key = JetstreamReservedKeys.EventReplayTopic.toString();

    if (event.containsKey(key)) {
      String retryTopic = (String) event.get(key);
      if (retryTopic != null && retryTopic.length() != 0) {
        retryTopic = "Replay-" + retryTopic.replaceAll("/", "-");
        event.setForwardingTopics(new String[] { retryTopic });
      }
    }

    super.sendEvent(event);
  }
}

if (Constants.EVENT_TYPE_SESSION_EXPIRED_EVENT.equals(firstEvent.getEventType())) {
    continue;
  SessionizationInfo info = (SessionizationInfo) firstEvent.remove(CURRENT_SESSIOIZERINFO);
  handleRawEvent(uid, identifier, null, firstEvent, sessionizer, info);
} else if (Constants.EVENT_TYPE_SESSION_TRANSFERED_EVENT.equals(firstEvent.getEventType())) {
  Session session = (Session) firstEvent.get(Constants.EVENT_PAYLOAD_SESSION_OBJ);
  if (session != null) {
    updateRemoteSession(uid, identifier, session, sessionizer);
    continue;
  SessionizationInfo info = (SessionizationInfo) firstEvent.remove(CURRENT_SESSIOIZERINFO);
  handleRawEvent(uid, identifier, localSessionCache.get(uid), firstEvent, sessionizer, info);
} else {
  SessionizationInfo info = (SessionizationInfo) firstEvent.remove(CURRENT_SESSIOIZERINFO);
  handleRawEvent(uid, identifier, null, firstEvent, sessionizer, info);
  Session session = localSessionCache.get(uid);
  while (nextEvent != null) {
    SessionizationInfo info = (SessionizationInfo) nextEvent.remove(CURRENT_SESSIOIZERINFO);
    updateSessionOnly(session, nextEvent, identifier, sessionizer, info);
    nextEvent = q.poll();

private void processSessionizableEvent(JetstreamEvent event, Sessionizer sessionizer, SessionizationInfo info) {
  counters.get(Integer.valueOf(sessionizer.getType())).incRawEvents();
  String identifier = info.getIdentifier();
  String ak = (String) event.get(AFFINITY_KEY);
  if (ak == null) {
    ak = identifier;
  }
  processNormalEvent(identifier, event, sessionizer, ak, info);
}

  evt = evt.clone();
} catch (CloneNotSupportedException e) {
  m_errors.registerError(e);
  evt.put(JetstreamReservedKeys.EventReplayTopic.toString(), topic);
    if (evt.containsKey(JetstreamReservedKeys.RetryCount
        .toString())) {
      retryCount = (Integer) evt
          .get(JetstreamReservedKeys.RetryCount
              .toString());
      retryCount++;
    evt.put(JetstreamReservedKeys.RetryCount.toString(),
        retryCount);
    sendToAdviceListener(evt, RetryEventCode.MSG_RETRY,

String[] forwardingTopics = event.getForwardingTopics();
    LOGGER.debug( "eventSource=" + getBeanName() + "&eventId = " + event.getEventId() + "&topic="
        + topic);
  if (event.containsKey(affinityKey)) {
    Object affkey = event.get(affinityKey);
          + event.get(affinityKey).toString() + " EVENT - " + event.toString());
  if (event.getMetaData(bcastMsg) != null) {
    any.setBroadcastMessage(Boolean.parseBoolean((String) event.getMetaData(bcastMsg)));
          + event.getMetaData(bcastMsg).toString() + " EVENT - " + event.toString());

private void sendToAdviceListener(JetstreamEvent event, RetryEventCode code, String msg) {
  try {
    if (m_adviceListener != null) {
      if (event.containsKey(JetstreamReservedKeys.RetryCount.toString())) {
        Integer retryCount = (Integer) event.get(JetstreamReservedKeys.RetryCount.toString());
        if (retryCount > 3) {
          LOGGER.info( "Unable to deliver this event so dropping it.." + event.getEventId());
          incrementEventDroppedCounter();
          return;
        }
      }
      m_adviceListener.retry(event, code, msg);
      m_eventSentToAdviceListener.increment();
    }
  }
  catch (Throwable e) {
    m_errors.registerError(e);
    LOGGER.error( e.getLocalizedMessage(), e);
  }
}

try {
  String metricName = (String) event
      .get(MCConstant.METRIC_NAME);
  String columnFamilyName = event.getEventType()
      .toLowerCase();
  if (event.get(MCConstant.METRIC_DEMENSION) != null) {
    MCMetricGroupDemension groupDemension = (MCMetricGroupDemension) event
        .get(MCConstant.METRIC_DEMENSION);
    groupId = groupDemension.getGroupId();
    if (event.get(MCConstant.TAG_TIME_IGNORE) != null) {
      tags = new HashMap<String, String>(
          groupDemension.getDimensions());
          MCConstant.TAG_TIME_IGNORE,
          (String) event
              .get(MCConstant.TAG_TIME_IGNORE));
    } else {
      tags = groupDemension.getDimensions();
    if (event.get(MCConstant.GROUP_ID) != null) {
      groupId = (String) event
          .get(MCConstant.GROUP_ID);
    } else {
      groupId = metricName;
  if (event.get(MCConstant.AGGREGATED_COUNT) != null) {
    count = (Long) event

while ((event = localQueue.poll()) != null) {
  @SuppressWarnings("unchecked")
  LinkedList<SessionizationInfo> pendingSessionizers = (LinkedList<SessionizationInfo>) event.get(SESSIONIZER_LIST);
  SessionizationInfo next = pendingSessionizers.removeFirst();
  if (pendingSessionizers.isEmpty()) {
    event.remove(SESSIONIZER_LIST);
  } else {
    String eventType = (String) event.get(JS_EVENT_TYPE);
    if (!interEventTypes.contains(eventType)) {
      eventCounters[taskId]++;
      } else if (m.size() == 1) {
        Entry<String, SessionizationInfo> entry = m.entrySet().iterator().next();
        event.put(CURRENT_SESSIOIZERINFO, entry.getValue());
        processSessionizableEvent(event, sessionizerMap.get(entry.getKey()), entry.getValue());
      } else {
        LinkedList<SessionizationInfo> slist = new LinkedList<SessionizationInfo>(m.values());
        event.put(SESSIONIZER_LIST, slist);
        SessionizationInfo sessionizationInfo = slist.removeFirst();
        event.put(CURRENT_SESSIOIZERINFO, sessionizationInfo);
        processSessionizableEvent(event, sessionizerMap.get(sessionizationInfo.getName()), sessionizationInfo);

  boolean serialized = false; 
  String[] forwardingTopics = event.getForwardingTopics();
      if (m_config.getTimestampKey() != null && !event.containsKey(m_config.getTimestampKey())) {
        event.put(m_config.getTimestampKey(), System.currentTimeMillis());
        injectTs = true;
lock.readLock().unlock();
if (injectTs) {
  event.remove(m_config.getTimestampKey());

@Override
public void sendEvent(JetstreamEvent event) throws EventException {
  if (event.getMetaData(Constants.REPLAY_INITIAL_TS) != null) {
    long initTs = (Long) event.getMetaData(Constants.REPLAY_INITIAL_TS);
    event.put(Constants.REPLAY_INITIAL_TS, initTs);
  if (event.getMetaData(Constants.REPLAY_LAST_TS) != null) {
    long lastTs = (Long) event.getMetaData(Constants.REPLAY_LAST_TS);
    event.put(Constants.REPLAY_LAST_TS, lastTs);
    postAlert(
        "The topic: "
            + event.get(JetstreamReservedKeys.EventReplayTopic.toString())
            + " has issue, replay occurs on replay agent",
            AlertStrength.RED);
    postAlert(
        "The topic: "
            + event.get(JetstreamReservedKeys.EventReplayTopic.toString())
            + " has issue, replay occurs on replay agent",
            AlertStrength.RED);

@Override
public void sendEvent(JetstreamEvent event) throws EventException {
  incrementEventRecievedCounter();
  String eventType = event.getEventType();
      && event.get("context_id") != dataByType.getLast().getEvents()
          .peek().get("context_id"))
    isNewBatchOfEvents = true;

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

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