How to use

com.ebay.jetstream.event.JetstreamEvent

constructor

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

private List<JetstreamEvent> createJetStreamCountEvent() {
  List<JetstreamEvent> result = new ArrayList<JetstreamEvent>(
      normalMetrics.size());
  for (Map.Entry<String, Counter> entry : normalMetrics.entrySet()) {
    String metricName = entry.getKey();
    Counter counter = entry.getValue();
    counter.mark();
    Map<String, Object> internalMap = new HashMap<String, Object>();
    if (counter instanceof AvgCounter) {
      internalMap.put(MCConstant.AGGREGATED_COUNT,
          ((AvgCounter) counter).getLatestAvgValue());
    } else {
      internalMap.put(MCConstant.AGGREGATED_COUNT,
          counter.getLastDeltaValue());
    }
    internalMap.put(MCConstant.METRIC_NAME, metricName);
    internalMap.put(MCConstant.METRIC_FREQUENCY,
        getFrequencyByMetricName(metricName));
    if (shutdownFlag.get()) {
      internalMap.put(MCConstant.SHUTDOWN_FLUSH,
          MCConstant.SHUTDOWN_FLUSH);
    }
    JetstreamEvent event = new JetstreamEvent(
        MCCounterHelper.COUNTEREVENT, null, internalMap);
    result.add(event);
  }
  return result;
}

private JetstreamEvent createEvent(Session session, String type) {
  JetstreamEvent jsEvent = new JetstreamEvent();
  jsEvent.setEventType(type);
  jsEvent.put(Constants.EVENT_PAYLOAD_SESSION_PAYLOAD, BinaryFormatSerializer.getInstance().getSessionPayload(session).array());
  jsEvent.put(Constants.EVENT_PAYLOAD_SESSION_METADATA, BinaryFormatSerializer.getInstance().getSessionMetadata(session).array());
  return jsEvent;
}

@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 flushMetrics(MetricDef metricDef) {
  Counter count = metrics.get(metricDef);
  count.mark();
  if (count.getLastDeltaValue() > 0) {
    Map<String, Object> internalMap = new HashMap<String, Object>();
    internalMap.put(MCConstant.METRIC_COUNT, count.getLastDeltaValue());
    internalMap.put(MCConstant.METRIC_NAME, metricDef.getMetricName());
    internalMap.put(MCConstant.GROUP_ID, metricDef.getMetricGroup());
    internalMap.put(MCConstant.METRIC_TIME, metricDef.getMetricTime());
    internalMap.put(MCConstant.METRIC_FREQUENCY,
        metricDef.getFrequency());
    internalMap.put(affinityKey, metricDef.getAffinityKey());
    JetstreamEvent event = new JetstreamEvent(
        metricDef.getMetricTable(), null, internalMap);
    event.setForwardingTopics(metricDef.getTopics());
    fireSendEvent(event);
    incrementEventSentCounter();
  }
}

@Override
public void remoteSessionExpired(String uid, String ak, byte[] payload, byte[] metadata) {
  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);
  jsEvent.put(Constants.EVENT_PAYLOAD_SESSION_PAYLOAD, payload);
  jsEvent.put(Constants.EVENT_PAYLOAD_SESSION_METADATA, metadata);
  
    
  int queueIndex = getQueueIndex(ak);
  try {
    responseQueues[queueIndex].put(jsEvent);
  } catch (InterruptedException e) {
    responseQueueFullCounter.incrementAndGet();
  }
}

@Override
public void remoteSessionLoaded(String uid, Session session, String ak) {
  JetstreamEvent event = new JetstreamEvent();
  event.setEventType(Constants.EVENT_TYPE_SESSION_LOAD_EVENT);
  int type = identifierType(uid);
  event.put(Constants.EVENT_PAYLOAD_SESSION_UNIQUEID, uid);
  event.put(Constants.EVENT_PAYLOAD_SESSION_OBJ, session);
  event.put(Constants.EVENT_PAYLOAD_SESSION_TYPE, Integer.valueOf(type));
  if (session != null) {
    session.setType(type);
    session.setIdentifier(identifierValue(uid));
  }
  int queueIndex = getQueueIndex(ak);
  try {
    responseQueues[queueIndex].put(event);
  } catch (InterruptedException e) {
    responseQueueFullCounter.incrementAndGet();
  }
}

JetstreamEvent event = new JetstreamEvent(
    metricTables.get(metricName), null, internalMap);
result.add(event);

@Override
public void onStatus(Status status) {
  HashtagEntity[] hashtagEntities = status.getHashtagEntities();
  
  JetstreamEvent event = new JetstreamEvent();
  event.setEventType("TwitterSample");
  Place place = status.getPlace();
  if (place != null) {
    event.put("country", place.getCountry());
  }
  event.put("ct", status.getCreatedAt().getTime());
  event.put("text", status.getText());
  event.put("lang", status.getLang());
  event.put("user", status.getUser().getName());
  if (hashtagEntities != null && hashtagEntities.length > 0) {
    StringBuilder s = new StringBuilder();
    s.append(hashtagEntities[0].getText());
    
    for (int i = 1; i < hashtagEntities.length; i++) {
      s.append(",");
      s.append(hashtagEntities[i].getText());
    }
    
    event.put("hashtag", s.toString());
  }
  fireSendEvent(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);
}

@Override
public JetstreamEvent decode(byte[] key, byte[] message) {
  try {
    @SuppressWarnings("unchecked")
    HashMap<String,Object> result =
        new ObjectMapper().readValue(factory.createJsonParser(message), HashMap.class);
    return new JetstreamEvent(result);
  } catch (JsonParseException e) {
    throw new IllegalArgumentException(
        "Fail to parse the bytes", e);
  } catch (JsonMappingException e) {
    throw new IllegalArgumentException(
        "Fail to parse the bytes", e);
  } catch (IOException e) {
    throw new IllegalArgumentException(
        "Fail to parse the bytes", e);
  }
}
 

String subSessionId = concatTimestamp(mainIdentifier, subSession.getIdentifier(), subSession.getFirstEventTimestamp());
subSession.setSessionId(subSessionId);
JetstreamEvent sessionEndEvent = new JetstreamEvent();
sessionEndEvent.setEventType(profile.getEndMarker());

@SuppressWarnings("unchecked")
@Override
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 ArrayList<Object> eventList = null;
 try {
  eventList = mapper.readValue(getContent(request), ArrayList.class);
 }
 catch (Throwable t) {
  LOGGER.error( "error unmarshalling JSON context -" + t.getLocalizedMessage());
  return;
 }
 JetstreamEvent event = null;
 Iterator<Object> itr = eventList.iterator();
 while (itr.hasNext()) {
  Map<String, Object> map = (Map<String, Object>) itr.next();
  event = new JetstreamEvent(map); // obj would be LinkedHashMap
  if (event != null) {
   m_inboundChannel.onMessage(event);
  }
 }
 
 response.setContentLength(0);
}

@SuppressWarnings("unchecked")
@Override
public JetstreamEvent decode(byte[] key, byte[] message) {
  ByteArrayInputStream stream = new ByteArrayInputStream(message);
  BinaryDecoder reusedDecoder = decoderHolder.get();
  BinaryDecoder decoder = DecoderFactory.get().directBinaryDecoder(stream, reusedDecoder);
  if (reusedDecoder == null) {
    decoderHolder.set(decoder);
  }
  Record object;
  try {
    object = reader.read(null, decoder);
    Map<String, Object> m = (Map<String, Object>) object.get(MAP_FIELD_NAME);
    return new JetstreamEvent(m);
  } catch (IOException e) {
    throw new IllegalArgumentException("Can not read the avro message", e);
  }
}

JetstreamEvent sessionBeginEvent = new JetstreamEvent();
sessionBeginEvent.setEventType(profile.getBeginMarker());
Map<String, Object> initialAttributes = subSession.getInitialAttributes();

  return;
JetstreamEvent sessionEndEvent = new JetstreamEvent();
sessionEndEvent.setEventType(mainSessionProfile.getEndMarker());
Map<String, Object> initialAttributes = session.getInitialAttributes();

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