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