001: package com.jamonapi;
002:
003: import java.util.*;
004:
005: import com.jamonapi.utils.*;
006:
007: /** <p>Factory used to hold JAMonListeners. Developers may put any listeners that implement
008: * JAMonBufferListeners.</p>
009: *
010: * <p>Any listener may be retrieved by passing in the JAMonListener name. At this time JAMon ships
011: * with the following listeners that can be referenced by name. Every buffer has a shared counterpart
012: * that allows different montiors to share the same buffer. In every other way they are
013: * the same as their similarly named counterparts.
014: * </p>
015: *
016: * <p>
017: * FIFOBuffer - Holds most recent objects in the buffer<br>
018: * NLargestValueBuffer - Keeps the largest values in the buffer<br>
019: * NSmallestValueBuffer - Keeps the smallest values in the buffer<br>
020: * NLargestValueBuffer7Days - When buffer is full the oldest data in buffer that is over 7 days is removed. If no data
021: * is older than 7 days then the smallest is removed. <br>
022: * NLargestValueBuffer24Hrs - When buffer is full the oldest data in buffer that is over 24 hours is removed. If no data
023: * is older than 7 days then the smallest is removed. <br>
024: * NSmallestValueBuffer7Days - When buffer is full the oldest data in buffer that is over 7 days is removed. If no data
025: * is older than 7 days then the largest is removed. <br>
026: * NSmallestValueBuffer24Hrs - When buffer is full the oldest data in buffer that is over 24 hours is removed. If no data
027: * is older than 7 days then the largest is removed. <br>
028: * SharedFIFOBuffer - Holds most recent objects in the buffer<br>
029: * SharedNLargestValueBuffer - Keeps the largest values in the buffer<br>
030: * SharedNSmallestValueBuffer - Keeps the smallest values in the buffer<br>
031: * SharedNLargestValueBuffer7Days - When buffer is full the oldest data in buffer that is over 7 days is removed. If no data
032: * is older than 7 days then the smallest is removed. <br>
033: * SharedNLargestValueBuffer24Hrs - When buffer is full the oldest data in buffer that is over 24 hours is removed. If no data
034: * is older than 7 days then the smallest is removed. <br>
035: * SharedNSmallestValueBuffer7Days - When buffer is full the oldest data in buffer that is over 7 days is removed. If no data
036: * is older than 7 days then the largest is removed. <br>
037: * SharedNSmallestValueBuffer24Hrs - When buffer is full the oldest data in buffer that is over 24 hours is removed. If no data
038: * is older than 7 days then the largest is removed. <br>
039: * HTTPBufferListener - Buffer that holds data specific to http requests.<br>
040: * ExceptionBufferListener - Buffer that holds data specific to monitors that track exceptions in the detail buffer<br>
041: *
042: * </p>
043:
044: * @author steve souza
045: *
046: */
047:
048: public class JAMonListenerFactory {
049: private static final boolean NATURAL_ORDER = true;
050: private static final boolean REVERSE_ORDER = false;
051:
052: private static String[] HEADER = { "ListenerName", "Listener" };
053: private static Map map = Misc.createCaseInsensitiveMap();
054:
055: static {
056: // put factory instances into the JAMonListenerFactory
057: put(getFIFO());
058: put(getNLargest());
059: put(getNSmallest());
060: put(getNLargest7Days());
061: put(getNLargest24Hrs());
062: put(getNSmallest7Days());
063: put(getNSmallest24Hrs());
064:
065: // allows sharing buffers between monitors!
066: put(getSharedFIFO());
067: put(getSharedNLargest());
068: put(getSharedNSmallest());
069: put(getSharedNLargest7Days());
070: put(getSharedNLargest24Hrs());
071: put(getSharedNSmallest7Days());
072: put(getSharedNSmallest24Hrs());
073:
074: put(getExceptionBufferListener());
075: put(getHTTPBufferListener());
076:
077: }
078:
079: /** Developers may register their own listeners to be made available for use in JAMon */
080: public static void put(JAMonListener jamonListener) {
081: map.put(jamonListener.getName(), jamonListener);
082: }
083:
084: /** Returns an array of all registered JAMonListeners in the format: key, JamonListener factory instance */
085: public static Object[][] getData() {
086: Iterator iter = map.entrySet().iterator();
087: Object[][] data = new Object[map.size()][];
088:
089: int i = 0;
090: while (iter.hasNext()) {
091: data[i] = new Object[2];
092: Map.Entry entry = (Map.Entry) iter.next();
093: data[i][0] = entry.getKey();
094: data[i][1] = entry.getValue();
095: i++;
096: }
097:
098: return data;
099: }
100:
101: /** Returns the header for display of JAMonListeners */
102: public static String[] getHeader() {
103: return HEADER;
104: }
105:
106: /** Get an instance of the named factory instance. If the Liistener implements
107: * CopyJAMonListener then copy will be called. If not then the default constructor will
108: * be called.
109: *
110: * @param listenerName
111: * @return
112: */
113: public static JAMonListener get(String listenerName) {
114: try {
115: JAMonListener factoryInstance = (JAMonListener) map
116: .get(listenerName);
117: if (factoryInstance instanceof CopyJAMonListener) {
118: return ((CopyJAMonListener) factoryInstance).copy();
119: } else {
120: JAMonListener newInst = (JAMonListener) factoryInstance
121: .getClass().newInstance();
122: newInst.setName(factoryInstance.getName());
123: return newInst;
124: }
125:
126: } catch (Exception e) {
127: throw new RuntimeException(
128: "Error getting listener from factory: "
129: + listenerName + ", " + e);
130: }
131:
132: }
133:
134: // Various factory methods used to populate the JAMonListenerFactory with default
135: // JAMonBufferListeners
136:
137: private static BufferHolder getBufferHolderNLargest7Days() {
138: // Keeps only the largest values within 7 days.
139: JAMonArrayComparator jac = new JAMonArrayComparator();
140: DateMathComparator dmc = new DateMathComparator(
141: Calendar.DAY_OF_YEAR, -7);
142: jac.addCompareCol(JAMonBufferListener.DATE_COL, dmc);
143: jac.addCompareCol(JAMonBufferListener.VALUE_COL, NATURAL_ORDER);
144:
145: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(jac);
146: return bufferHolder;
147: }
148:
149: private static BufferHolder getBufferHolderNLargest24Hrs() {
150: // Keeps only the largest values within 24 hrs.
151: JAMonArrayComparator jac = new JAMonArrayComparator();
152: DateMathComparator dmc = new DateMathComparator(
153: Calendar.HOUR_OF_DAY, -24);
154: jac.addCompareCol(JAMonBufferListener.DATE_COL, dmc);
155: jac.addCompareCol(JAMonBufferListener.VALUE_COL, NATURAL_ORDER);
156:
157: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(jac);
158: return bufferHolder;
159: }
160:
161: private static BufferHolder getBufferHolderNSmallest7Days() {
162: // Keeps only the smallest values within 7 days.
163: JAMonArrayComparator jac = new JAMonArrayComparator();
164: DateMathComparator dmc = new DateMathComparator(
165: Calendar.DAY_OF_YEAR, -7);
166: jac.addCompareCol(JAMonBufferListener.DATE_COL, dmc);
167: jac.addCompareCol(JAMonBufferListener.VALUE_COL, REVERSE_ORDER);
168:
169: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(jac);
170: return bufferHolder;
171:
172: }
173:
174: private static BufferHolder getBufferHolderNSmallest24Hrs() {
175: // Keeps only the smallest values within 24 hrs.
176: JAMonArrayComparator jac = new JAMonArrayComparator();
177: DateMathComparator dmc = new DateMathComparator(
178: Calendar.HOUR_OF_DAY, -24);
179: jac.addCompareCol(JAMonBufferListener.DATE_COL, dmc);
180: jac.addCompareCol(JAMonBufferListener.VALUE_COL, REVERSE_ORDER);
181:
182: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(jac);
183: return bufferHolder;
184:
185: }
186:
187: private static JAMonBufferListener getFIFO() {
188: BufferHolder bufferHolder = new FIFOBufferHolder();
189: BufferList bufferList = new BufferList(
190: JAMonBufferListener.DEFAULT_HEADER, bufferHolder);
191: return new JAMonBufferListener("FIFOBuffer", bufferList);
192: }
193:
194: private static JAMonBufferListener getNLargest() {
195: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(
196: NATURAL_ORDER, JAMonBufferListener.VALUE_COL);
197: BufferList bufferList = new BufferList(
198: JAMonBufferListener.DEFAULT_HEADER, bufferHolder);
199: return new JAMonBufferListener("NLargestValueBuffer",
200: bufferList);
201:
202: }
203:
204: private static JAMonBufferListener getNSmallest() {
205: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(
206: REVERSE_ORDER, JAMonBufferListener.VALUE_COL);
207: BufferList bufferList = new BufferList(
208: JAMonBufferListener.DEFAULT_HEADER, bufferHolder);
209: return new JAMonBufferListener("NSmallestValueBuffer",
210: bufferList);
211:
212: }
213:
214: private static JAMonBufferListener getNLargest7Days() {
215: BufferList bufferList = new BufferList(
216: JAMonBufferListener.DEFAULT_HEADER,
217: getBufferHolderNLargest7Days());
218: return new JAMonBufferListener("NLargestValueBuffer7Days",
219: bufferList);
220:
221: }
222:
223: private static JAMonBufferListener getNLargest24Hrs() {
224: BufferList bufferList = new BufferList(
225: JAMonBufferListener.DEFAULT_HEADER,
226: getBufferHolderNLargest24Hrs());
227: return new JAMonBufferListener("NLargestValueBuffer24Hrs",
228: bufferList);
229:
230: }
231:
232: private static JAMonBufferListener getNSmallest7Days() {
233: BufferList bufferList = new BufferList(
234: JAMonBufferListener.DEFAULT_HEADER,
235: getBufferHolderNSmallest7Days());
236: return new JAMonBufferListener("NSmallestValueBuffer7Days",
237: bufferList);
238:
239: }
240:
241: private static JAMonBufferListener getNSmallest24Hrs() {
242: BufferList bufferList = new BufferList(
243: JAMonBufferListener.DEFAULT_HEADER,
244: getBufferHolderNSmallest24Hrs());
245: return new JAMonBufferListener("NSmallestValueBuffer24Hrs",
246: bufferList);
247:
248: }
249:
250: private static JAMonBufferListener getSharedFIFO() {
251: BufferHolder bufferHolder = new FIFOBufferHolder();
252: BufferList bufferList = new BufferList(
253: JAMonBufferListener.DEFAULT_HEADER, bufferHolder);
254: return new SharedJAMonBufferListener("SharedFIFOBuffer",
255: bufferList);
256: }
257:
258: private static JAMonBufferListener getSharedNSmallest() {
259: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(
260: REVERSE_ORDER, JAMonBufferListener.VALUE_COL);
261: BufferList bufferList = new BufferList(
262: JAMonBufferListener.DEFAULT_HEADER, bufferHolder);
263: return new SharedJAMonBufferListener(
264: "SharedNSmallestValueBuffer", bufferList);
265:
266: }
267:
268: private static JAMonBufferListener getSharedNLargest() {
269: BufferHolder bufferHolder = new NExtremeArrayBufferHolder(
270: NATURAL_ORDER, JAMonBufferListener.VALUE_COL);
271: BufferList bufferList = new BufferList(
272: JAMonBufferListener.DEFAULT_HEADER, bufferHolder);
273: return new SharedJAMonBufferListener(
274: "SharedNLargestValueBuffer", bufferList);
275:
276: }
277:
278: private static JAMonBufferListener getSharedNLargest7Days() {
279: BufferList bufferList = new BufferList(
280: JAMonBufferListener.DEFAULT_HEADER,
281: getBufferHolderNLargest7Days());
282: return new SharedJAMonBufferListener(
283: "SharedNLargestValueBuffer7Days", bufferList);
284:
285: }
286:
287: private static JAMonBufferListener getSharedNLargest24Hrs() {
288: BufferList bufferList = new BufferList(
289: JAMonBufferListener.DEFAULT_HEADER,
290: getBufferHolderNLargest24Hrs());
291: return new SharedJAMonBufferListener(
292: "SharedNLargestValueBuffer24Hrs", bufferList);
293:
294: }
295:
296: private static JAMonBufferListener getSharedNSmallest7Days() {
297: BufferList bufferList = new BufferList(
298: JAMonBufferListener.DEFAULT_HEADER,
299: getBufferHolderNSmallest7Days());
300: return new SharedJAMonBufferListener(
301: "SharedNSmallestValueBuffer7Days", bufferList);
302:
303: }
304:
305: private static JAMonBufferListener getSharedNSmallest24Hrs() {
306: BufferList bufferList = new BufferList(
307: JAMonBufferListener.DEFAULT_HEADER,
308: getBufferHolderNSmallest24Hrs());
309: return new SharedJAMonBufferListener(
310: "SharedNSmallestValueBuffer24Hrs", bufferList);
311:
312: }
313:
314: private static JAMonBufferListener getExceptionBufferListener() {
315: String[] header = new String[] { "Label", "Exception",
316: "LastValue", "Active", "Date" };
317: BufferHolder bufferHolder = new FIFOBufferHolder();
318: BufferList bufferList = new BufferList(header, bufferHolder);
319: return new JAMonArrayBufferListener("ExceptionBufferListener",
320: bufferList);
321: }
322:
323: private static JAMonBufferListener getHTTPBufferListener() {
324: String[] header = new String[] { "Label", "Exception",
325: "LastValue", "Active", "Date" };
326: BufferHolder bufferHolder = new FIFOBufferHolder();
327: BufferList bufferList = new BufferList(header, bufferHolder);
328: return new JAMonArrayBufferListener("HTTPBufferListener",
329: bufferList);
330: }
331:
332: // called from main method for testing purposes
333: private static void testArray(String label, int dateToAdd,
334: boolean increase) {
335: System.out.print("\n\n****" + label);
336: JAMonBufferListener jbl = (JAMonBufferListener) get(label);
337: BufferList bl = jbl.getBufferList();
338:
339: Calendar cal = new GregorianCalendar();
340: if (increase) {
341: for (int i = 1, j = -50; i <= 100; i++, j++) {
342: cal.setTime(new Date());
343: cal.add(dateToAdd, j);
344: bl.addRow(new Object[] { "label" + i, new Integer(i),
345: "Active" + i, cal.getTime() });
346: }
347:
348: } else {
349: for (int i = 100, j = 50; i >= 1; i--, j--) {
350: cal.setTime(new Date());
351: cal.add(dateToAdd, j);
352: bl.addRow(new Object[] { "label" + i, new Integer(i),
353: "Active" + i, cal.getTime() });
354: }
355:
356: }
357:
358: // firstVal will be under date threshold, and secondVal will exceed it.
359: int firstVal = -5;
360: int secondVal = -10;
361:
362: if (dateToAdd == Calendar.HOUR_OF_DAY) {
363: firstVal = -12;
364: secondVal = -36;
365: }
366:
367: cal.setTime(new Date());
368: cal.add(dateToAdd, firstVal);
369: bl.addRow(new Object[] { "label", new Integer(1000), "Active",
370: cal.getTime() });
371:
372: cal.setTime(new Date());
373: cal.add(dateToAdd, firstVal);
374: bl.addRow(new Object[] { "label", new Integer(-1000), "Active",
375: cal.getTime() });
376:
377: cal.setTime(new Date());
378: cal.add(dateToAdd, secondVal);
379: bl.addRow(new Object[] { "label", new Integer(1000), "Active",
380: cal.getTime() });
381:
382: cal.setTime(new Date());
383: cal.add(dateToAdd, secondVal);
384: bl.addRow(new Object[] { "label", new Integer(-1000), "Active",
385: cal.getTime() });
386:
387: Misc.disp(bl.getData());
388:
389: }
390:
391: public static void main(String[] args) {
392: System.out
393: .println("/n*****Testing JAMonListenerFactory.main()");
394: put(new CompositeListener("tester"));
395: put(new JAMonBufferListener("helloListener", new BufferList(
396: new String[] { "hey" }, 200)));
397: String[] header = getHeader();
398: Object[][] data = getData();
399: for (int i = 0; i < data.length; i++)
400: for (int j = 0; j < data[i].length; j++)
401: System.out.println(header[j] + "=" + data[i][j]);
402:
403: System.out.println("\ngetting listener=" + get("FIFOBuffer"));
404: JAMonBufferListener jbl = (JAMonBufferListener) get("helloListener");
405: System.out.println("name=" + jbl.getName() + ", buffer="
406: + jbl.getBufferList().getBufferSize());
407:
408: // The following tests run buffers with data inserted in natural, and
409: // reverse order to see if both work.
410: testArray("FIFOBuffer", Calendar.DAY_OF_YEAR, true);
411: testArray("FIFOBuffer", Calendar.DAY_OF_YEAR, false);
412: testArray("NLargestValueBuffer", Calendar.DAY_OF_YEAR, true);
413: testArray("NLargestValueBuffer", Calendar.DAY_OF_YEAR, false);
414: testArray("NSmallestValueBuffer", Calendar.DAY_OF_YEAR, true);
415: testArray("NSmallestValueBuffer", Calendar.DAY_OF_YEAR, false);
416: testArray("NLargestValueBuffer7Days", Calendar.DAY_OF_YEAR,
417: true);
418: testArray("NLargestValueBuffer7Days", Calendar.DAY_OF_YEAR,
419: false);
420: testArray("NSmallestValueBuffer7Days", Calendar.DAY_OF_YEAR,
421: true);
422: testArray("NSmallestValueBuffer7Days", Calendar.DAY_OF_YEAR,
423: false);
424: testArray("NLargestValueBuffer24Hrs", Calendar.HOUR_OF_DAY,
425: false);
426: testArray("NSmallestValueBuffer24Hrs", Calendar.HOUR_OF_DAY,
427: true);
428:
429: }
430:
431: }
|