/** * Creates a {@link BaseMonitoringEngineManager} * @param factory used to create {@link MonitorProcessor MonitorProcessors} * @param decomposer used to make properties of monitors {@link Serializable} */ public BaseMonitoringEngineManager(final MonitorProcessorFactory factory, Decomposer decomposer) { if (decomposer == null) { decomposer = new AttributeDecomposer(); } this.factory = factory; this.decomposer = decomposer; this.inheritableStrategy = new StackBasedInheritableStrategy(); }
public int clearCurrentThread() { LinkedList stack = getStack(); int count = 0; if (stack != null) { count = stack.size(); if (count > 0) { StringBuffer monitorNames = new StringBuffer(); for (Iterator i = stack.iterator(); i.hasNext();) { StackFrame stackFrame = (StackFrame) i.next(); Monitor m = stackFrame.getCompositeMonitor(); String s = (String) m.get(Attribute.NAME); if (monitorNames.length() > 0) { monitorNames.append(", "); } monitorNames.append(s); } log.warn("clearing old CompositeMonitor refs for current thread; "+count+" found; names: "+monitorNames); stack.clear(); } } return count; }
public void processMonitorForCompositeMonitor(Monitor monitor) { LinkedList stack = getStack(); if (stack != null) { if (! stack.isEmpty()) { StackFrame stackFrame = (StackFrame) stack.getLast(); CompositeMonitor parentMonitor = stackFrame.getCompositeMonitor(); // only add this monitor being processed to a parent if it is enabled // by its monitoring level MonitoringLevel monitorLevel = monitor.getLevel(); if ((monitorLevel != null) && (monitorLevel.hasHigherOrEqualPriorityThan(getEventPatternLevel()))) { parentMonitor.addChildMonitor(monitor); } } else { threadBasedMap.remove(Thread.currentThread()); } } }
/** * This method should be called by all CompositeMonitor implementations * before they call monitorStarted(). * * @param compositeMonitor the composite monitor */ public void compositeMonitorStarted(CompositeMonitor compositeMonitor) { if (getEventPatternLevel().hasHigherPriorityThan(compositeMonitor.getLevel())) { if (log.isDebugEnabled()) { log.debug("skipping " + compositeMonitor.getAsString(Attribute.NAME)); } return; } LinkedList stack = getStack(); if (stack == null) { stack = new LinkedList(); threadBasedMap.put(Thread.currentThread(), stack); } stack.addLast(new StackFrame(compositeMonitor)); }
/** * This method should be called by all CompositeMonitor implementations * before they call process(). * * @param monitor the monitor that is completed */ public void compositeMonitorCompleted(CompositeMonitor monitor) { LinkedList stack = getStack(); if (stack != null && !stack.isEmpty()) { StackFrame target = new StackFrame(monitor); if (!stack.getLast().equals(target) && !stack.contains(target)) { // This monitor is being double processed on accident. // Ignore it. return; } while (!stack.getLast().equals(target)) { // A child monitor was not processed, process them now. StackFrame stackFrame = (StackFrame) stack.removeLast(); CompositeMonitor missedMonitor = stackFrame.getCompositeMonitor(); String name = (String) missedMonitor.get(Attribute.NAME); log.warn("unfinished child monitor \""+name+"\" found so will process now and remove; app is fine"); MonitoringEngine.getInstance().process(missedMonitor); } stack.removeLast(); } }
LinkedList stack = getStack(); while (i.hasNext()) { StackFrame stackFrame = (StackFrame) i.next(); CompositeMonitor monitor = stackFrame.getCompositeMonitor(); inheritable.putAll(monitor.getInheritableAttributeHolders()); CompositeMonitor parent = stackFrame.getCompositeMonitor(); if (stack != null && !stack.isEmpty()) { StackFrame stackFrame = (StackFrame) stack.getLast(); AtomicInteger counter = stackFrame.getCounter(); sequenceId += "_" + counter.getAndIncrement();
public void setInheritable(CompositeMonitor monitor, String key, AttributeHolder original) { Map inheritableAttributes = getInheritableAttributes(); if(!inheritableAttributes.containsKey(key) && original != null) { compositeMonitorStarted(monitor); Map map = (Map) threadBasedMap.get(Thread.currentThread()); if(!map.containsKey(monitor)) { map.put(monitor, new HashMap()); } Map monitorMap = (Map) map.get(monitor); monitorMap.put(key, original); } else { if(log.isDebugEnabled()) { AttributeHolder holder = (AttributeHolder) inheritableAttributes.get(key); log.debug("Attempted to re-add " + key + " with new value [" + original.getValue() + "] to inheritableMap; old value is [" + holder.getValue() + "]"); } } }
protected MonitoringEngine() { monitorProcessorLevels = new HashMap(); monitorLevels = new TreeMap(Collections.reverseOrder()); globalAttributes = new AttributeMap(); inheritableStrategy = new MapBasedInheritableStrategy(); }
LinkedList stack = getStack(); CompositeMonitor monitor = stackFrame.getCompositeMonitor();