public void process(Monitor monitor) { if (CompositeMonitor.class.isAssignableFrom(monitor.getClass()) && !monitor.hasAttribute("resultCode")) { if (monitor.hasAttribute("failureThrowable")) { Throwable t = (Throwable) monitor.get("failureThrowable"); while (t.getCause() != null) { t = t.getCause(); } monitor.set("resultCode", t.getClass().getName()); } else { monitor.set("resultCode", "success"); } } } }
public void process(Monitor monitor) { if (monitor == null) { return; } if (monitor.hasAttribute(Attribute.LATENCY)) { _statsdClient.timing(monitor.getAsString(Attribute.NAME), monitor.getAsInt(Attribute.LATENCY)); } else if (monitor.hasAttribute(Attribute.VALUE)) { _statsdClient.gauge(monitor.getAsString(Attribute.NAME), (int) monitor.getAsInt(Attribute.VALUE)); } else { _statsdClient.increment(monitor.getAsString(Attribute.NAME)); } if (monitor.getAsBoolean(Attribute.FAILED, false)) { _statsdClient.increment(monitor.getAsString(Attribute.NAME) + ".failed"); } }
public void monitorStarted(final Monitor monitor) { _monitorProcessingExecutor.execute(new MonitorProcessBundle(monitor.getSerializableMomento()) { @Override protected void processWithProcessor(final MonitorProcessor processor) { processor.monitorStarted(_monitor); } }); }
private String getAttributeAsStringWithDefault(Monitor monitor, String attributeKey, String defaultValue) { if (!monitor.hasAttribute(attributeKey)) { return defaultValue; } else { return monitor.getAsString(attributeKey); } }
protected void appendMonitorDataAsAttributes(HierarchicalStreamWriter writer, Monitor monitor) { Iterator it = allowedAttributes.iterator(); while (it.hasNext()) { String attributeName = (String) it.next(); if (monitor.hasAttribute(attributeName)) { String attributeValue = monitor.getAsString(attributeName); if (attributeValue == null) { writer.addAttribute(attributeName, "null"); } else { if (attributeValue.indexOf("LazyDynaBean") > -1) { DynaBean dynaBean = (DynaBean) monitor.get(attributeName); Object clazz = dynaBean.get("class"); if (clazz != null) { attributeValue = clazz.toString(); } } int idx = attributeValue.indexOf("\n"); if(idx > -1) { attributeValue = attributeValue.substring(0, idx); } writer.addAttribute(attributeName, attributeValue); } } } } }
if (attributeName.equals(Attribute.FAILURE_THROWABLE)) { assignFailureThrowable(monitor, buffer); } else if (monitor.hasAttribute(attributeName)) { Object attributeValue = monitor.get(attributeName); buffer.append(attributeValue).append(delimeter);
@Override public void process(final Monitor monitor) { if (isEnabled && TransactionMonitor.class.isAssignableFrom(monitor.getClass())) { String name = monitor.getAsString(Attribute.NAME); synchronized (map) { Integer cnt = map.get(name); if (cnt == null) { log.warn("No count available for Monitor named " + name); } else { int count = cnt.intValue(); map.put(name, Integer.valueOf(count - 1)); monitor.set("concurrencyCount", count); } } } }
private void inheritAttributesFromAncestors(final Monitor monitor) { // Inherit from parent if not set. final Map attrs = getInheritableAttributes(); for (final Iterator it = attrs.entrySet().iterator(); it.hasNext();) { final Map.Entry entry = (Map.Entry)it.next(); final String key = (String)entry.getKey(); final AttributeHolder parentAttribute = (AttributeHolder)entry.getValue(); if (!monitor.hasAttribute(key)) { final Object value = parentAttribute.getValue(); final AttributeHolder childAttribute = monitor.set(key, value); if (parentAttribute.isSerializable()) { childAttribute.serializable(); } if (parentAttribute.isLocked()) { childAttribute.lock(); } } } }
public void monitorStarted(Monitor monitor) { if (enabled && TransactionMonitor.class.isAssignableFrom(monitor.getClass())) { ThreadMXBean tmxbean = ManagementFactory.getThreadMXBean(); long id = Thread.currentThread().getId(); ThreadInfo threadInfo = tmxbean.getThreadInfo(id); monitor.set("startBlockedCount", threadInfo.getBlockedCount()); monitor.set("startBlockedTime", threadInfo.getBlockedTime()); monitor.set("startWaitedCount", threadInfo.getWaitedCount()); monitor.set("startWaitedTime", threadInfo.getWaitedTime()); } }
@Override public void process(final Monitor monitor) { if (enabled && TransactionMonitor.class.isAssignableFrom(monitor.getClass())) { ThreadMXBean tmxbean = ManagementFactory.getThreadMXBean(); long endTime = tmxbean.getCurrentThreadCpuTime(); monitor.set("endCPUTime", endTime); long diff = endTime - monitor.getAsLong("startCPUTime"); double cpuTimeMillis = diff / 1000000.0; if (log.isDebugEnabled()) { log.debug("cpuTimeMillis=" + cpuTimeMillis); } monitor.set("cpuTimeMillis", cpuTimeMillis); } }
return Collections.emptyList(); final MonitoringLevel monitorLevel = monitor.getLevel();
@Override public void monitorStarted(final Monitor monitor) { if (isEnabled && TransactionMonitor.class.isAssignableFrom(monitor.getClass())) { String name = monitor.getAsString(Attribute.NAME); synchronized (map) { Integer cnt = map.get(name); if (cnt == null) { map.put(name, Integer.valueOf(1)); } else { int count = cnt.intValue(); map.put(name, Integer.valueOf(count + 1)); } } } }
/** * Accepts the given monitor if that current sample percentage is less than the target sample rate. * * @param monitor monitor instance * @return true if the monitor should be accepted in the sample */ public boolean accept(Monitor monitor) { sampleRateLock.lock(); boolean shouldAccept; float actualRate; try { if (populationCount == Integer.MAX_VALUE) { populationCount = 0; sampledCount = 0; } populationCount++; actualRate = (sampledCount / ((float)populationCount)); shouldAccept = (actualRate < sampleRate); if (shouldAccept) { sampledCount++; } } finally { sampleRateLock.unlock(); } if (logger.isDebugEnabled()) { logger.debug((shouldAccept ? "ACCEPTED" : "REJECTED") + " monitor \"" + monitor.get(Monitor.NAME) + "\" due to actual sample rate of " + actualRate + " and target " + this.sampleRate); } return shouldAccept; }
/** * Renders a Monitor in a multiple-line String format. * @param monitor monitor to render * @param includeStackTraces true if every Throwable attribute value should render with a stack trace * @return a String representation of the monitor. */ public String renderMonitor(Monitor monitor, boolean includeStackTraces) { if (monitor == null) { return "null"; } StringBuffer buf = new StringBuffer(monitor.getClass().getName()); Map attributeMap = monitor.getAll(); buf.append(renderMonitor(attributeMap, includeStackTraces)); return buf.toString(); }
protected boolean shouldRender(Monitor monitor) { boolean render = true; if(!logger.isDebugEnabled()) { if (monitor.hasAttribute(Attribute.NAME)) { String name = monitor.getAsString(Attribute.NAME); Iterator it = monitorsToSkip.iterator(); while(render && it.hasNext()) { String sName = (String) it.next(); if (name.indexOf(sName) > -1) { render = false; } } } } return render; }
private void assignFailureThrowable(Monitor monitor, StringBuffer buffer) { if (! monitor.hasAttribute(Attribute.FAILURE_THROWABLE)) { return; Object o = monitor.get(Attribute.FAILURE_THROWABLE); if (Throwable.class.isAssignableFrom(o.getClass())) { Throwable t = (Throwable) o;
@Override public void monitorStarted(final Monitor monitor) { if (enabled && TransactionMonitor.class.isAssignableFrom(monitor.getClass())) { ThreadMXBean tmxbean = ManagementFactory.getThreadMXBean(); monitor.set("startCPUTime", tmxbean.getCurrentThreadCpuTime()); } }
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()); } } }
/** * Given a monitor, look at its name and see if there has been an updated level set during * runtime. The updated level can apply for a specific monitor "com.orbitz.foo.bar" or any package * "com.orbitz.foo" * * @param monitor the monitor to check for an updated level * @return the appropiate level for this monitor, if a new level has been set at runtime that will * be returned, if not the monitor's level set at construction time will be returned. */ public MonitoringLevel getOverrideLevelForMonitor(final Monitor monitor) { final String name = monitor.getAsString(Attribute.NAME); final Set keys = monitorLevels.keySet(); final Iterator itr = keys.iterator(); String keyToUse = null; while (itr.hasNext()) { final String key = (String)itr.next(); if (name.startsWith(key)) { keyToUse = key; break; } } return (keyToUse != null ? (MonitoringLevel)monitorLevels.get(keyToUse) : null); }
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; }