circuitbreaker/statistics/LoggingStatistics.java

package dk.thoerup.circuitbreaker.statistics;

import java.util.Date;
import java.util.LinkedList;

import dk.thoerup.circuitbreaker.Event;

public class LoggingStatistics extends AccountingStatistics {
        
        private LinkedList<LogEntry> log = new LinkedList<LogEntry>();

        final int maxSize = 50;

        public static class LogEntry {
                public long time;
                public Event event;
                public int count = 1;
        
                public LogEntry(Event evnt) {
                        this.event = evnt;
                        this.time = System.currentTimeMillis();
                }
                
                public void newRetrip() {//
                        count++;
                        time = System.currentTimeMillis(); 
                }
                
                @Override
                public String toString() {
                        
                        String str = new Date(time).toString() + (" : ") + event;
                        
                        if (event == Event.BreakerRetripped) {
                                str += ( ", " + count + " re-trips" );
                        }
                        
                        return str ;
                }
        }
        
        
        @Override
        public void addStatistics(Event event) {
                
                super.addStatistics(event);
                
                switch(event) {

                case BreakerReset:
                        addEntry(Event.BreakerReset);
                        break;
                case BreakerRetripped:
                        addEntry(Event.BreakerRetripped);                       
                        break;
                case BreakerTripped:
                        addEntry(Event.BreakerTripped);
                        break;
                        
                /*case InvocationBlocked:
                        break;
                case InvocationFailure:                 
                        break;
                case Invocation:
                        break;
                case BreakerAttemptReset:
                        break;                  
                        */
                        
                default:
                        break;
                }
        }
        
        private void addEntry(Event event) {
                synchronized(this) {

                        if (event != Event.BreakerRetripped ) {
                                log.addFirst( new LogEntry(event) ); //trip and reset are added unconditionally
                        } else {
                                
                                if (log.size() == 0 || log.getFirst().event != Event.BreakerRetripped) {
                                        log.addFirst( new LogEntry(event) );
                                } else {
                                        log.getFirst().newRetrip(); 
                                }                               
                        }

                        if(log.size() > maxSize) {
                                log.removeLast();
                        }

                }
        }

        public void clearLog() {
                synchronized(this) {
                        log.clear();
                }
        }

        public LinkedList<LogEntry> getLog() {
                synchronized(this) {
                        return new LinkedList<LogEntry>(log); //return a copy so caller can to whatever he wants, when he wants
                }
        }
        
}
1	torben	2569	package dk.thoerup.circuitbreaker.statistics;
2
3			import java.util.Date;
4			import java.util.LinkedList;
5
6			import dk.thoerup.circuitbreaker.Event;
7
8			public class LoggingStatistics extends AccountingStatistics {
9
10			private LinkedList<LogEntry> log = new LinkedList<LogEntry>();
11
12			final int maxSize = 50;
13
14			public static class LogEntry {
15			public long time;
16			public Event event;
17			public int count = 1;
18
19			public LogEntry(Event evnt) {
20			this.event = evnt;
21			this.time = System.currentTimeMillis();
22			}
23
24			public void newRetrip() {//
25			count++;
26			time = System.currentTimeMillis();
27			}
28
29			@Override
30			public String toString() {
31
32			String str = new Date(time).toString() + (" : ") + event;
33
34			if (event == Event.BreakerRetripped) {
35			str += ( ", " + count + " re-trips" );
36			}
37
38			return str ;
39			}
40			}
41
42
43			@Override
44			public void addStatistics(Event event) {
45
46			super.addStatistics(event);
47
48			switch(event) {
49
50			case BreakerReset:
51			addEntry(Event.BreakerReset);
52			break;
53			case BreakerRetripped:
54			addEntry(Event.BreakerRetripped);
55			break;
56			case BreakerTripped:
57			addEntry(Event.BreakerTripped);
58			break;
59
60			/*case InvocationBlocked:
61			break;
62			case InvocationFailure:
63			break;
64			case Invocation:
65			break;
66			case BreakerAttemptReset:
67			break;
68			*/
69
70			default:
71			break;
72			}
73			}
74
75			private void addEntry(Event event) {
76			synchronized(this) {
77
78			if (event != Event.BreakerRetripped ) {
79			log.addFirst( new LogEntry(event) ); //trip and reset are added unconditionally
80			} else {
81
82			if (log.size() == 0 \|\| log.getFirst().event != Event.BreakerRetripped) {
83			log.addFirst( new LogEntry(event) );
84			} else {
85			log.getFirst().newRetrip();
86			}
87			}
88
89			if(log.size() > maxSize) {
90			log.removeLast();
91			}
92
93			}
94			}
95
96			public void clearLog() {
97			synchronized(this) {
98			log.clear();
99			}
100			}
101
102			public LinkedList<LogEntry> getLog() {
103			synchronized(this) {
104			return new LinkedList<LogEntry>(log); //return a copy so caller can to whatever he wants, when he wants
105			}
106			}
107
108			}