thoerup/circuitbreaker/LoggingCircuitBreaker.java

package dk.thoerup.circuitbreaker;

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

import dk.thoerup.circuitbreaker.config.BreakerConfig;

@Deprecated
public class LoggingCircuitBreaker extends AccountingCircuitBreaker {

        private LinkedList<LogEntry> log = new LinkedList<LogEntry>();

        final int maxSize = 50;

        public 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 ;
                }
        }
        
        
        public LoggingCircuitBreaker(String name, BreakerConfig config) {
                super(name, config);

        }

        @Override
        public void tripBreaker() {
                super.tripBreaker();
                addEntry(Event.BreakerTripped);
        }

    
        @Override
        public void retripBreaker() {
                super.retripBreaker();
                addEntry(Event.BreakerRetripped);
        }


        @Override
        public void reset() {
                super.reset();
                addEntry(Event.BreakerReset);
        }

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