thoerup/circuitbreaker/LoggingCircuitBreaker.java

package dk.thoerup.circuitbreaker;

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

import dk.thoerup.circuitbreaker.notification.Notifier;

public class LoggingCircuitBreaker extends AccountingCircuitBreaker {

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

        final int maxSize = 50;

        public class LogEntry {
                public long time;
                public Notifier.Event event;
                public int count = 0;
        
                public LogEntry(Notifier.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 == Notifier.Event.BreakerRetripped) {
                                str += ( ", " + count + " re-trips" );
                        }
                        
                        return str ;
                }
        }
        
        
        public LoggingCircuitBreaker(String name, int threshold, long timeoutMS) {
                super(name, threshold, timeoutMS);

        }

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

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


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

        private void addEntry(Notifier.Event event) {
                synchronized(this) {

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