thoerup/traininfoservice/Statistics.java

package dk.thoerup.traininfoservice;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang.time.DurationFormatUtils;

public class Statistics {
        
        private AtomicInteger stationLookupsLocation = new AtomicInteger(0);
        private AtomicInteger stationLookupsName = new AtomicInteger(0);
        private AtomicInteger stationLookupsFavorites = new AtomicInteger(0);
        private AtomicInteger departureLookups = new AtomicInteger(0);
        private AtomicInteger timetableLookups = new AtomicInteger(0);  
        private AtomicInteger departureCacheHits = new AtomicInteger(0);
        private AtomicInteger timetableCacheHits = new AtomicInteger(0);
        private AtomicInteger departureErrors = new AtomicInteger(0);
        private AtomicInteger timetableErrors = new AtomicInteger(0);
        
        private int old_stationLookupsLocation = 0;
        private int old_stationLookupsName = 0;
        private int old_stationLookupsFavorites = 0;
        private int old_departureLookups = 0;
        private int old_timetableLookups = 0;   
        private int old_departureCacheHits = 0;
        private int old_timetableCacheHits = 0;
        private int old_departureErrors = 0;
        private int old_timetableErrors = 0;
        
        private Date lastReset = new Date();
        
        public void incrementStationLookupsLocation() {
                stationLookupsLocation.incrementAndGet();
        }
        
        public void incrementStationLookupsName() {
                stationLookupsName.incrementAndGet();
        }
        
        public void incrementStationLookupsFavorites() {
                stationLookupsFavorites.incrementAndGet();
        }
        
        public void incrementDepartureLookups() {
                departureLookups.incrementAndGet();
        }
        
        public void incrementTimetableLookups() {
                timetableLookups.incrementAndGet();
        }
        
        public void incrementDepartureCacheHits() {
                departureCacheHits.incrementAndGet();
        }
        
        public void incrementTimetableCacheHits() {
                timetableCacheHits.incrementAndGet();
        }
        
        public void incrementDepartureErrors() {
                departureErrors.incrementAndGet();
        }
        
        public void incrementTimetableErrors() {
                timetableErrors.incrementAndGet();
        }
        
        /////////
        
        public int getStationTotals() {
                return stationLookupsLocation.get() + stationLookupsName.get() + stationLookupsFavorites.get();
        }
        
        public int getStationLookupsLocation() {
                return stationLookupsLocation.get();
        }
        
        public int getStationLookupsName() {
                return stationLookupsName.get();
        }
        
        public int getStationLookupsFavorites() {
                return stationLookupsFavorites.get();
        }
        
        public int getDepartureLookups() {
                return departureLookups.get();
        }
        
        public int getTimetableLookups() {
                return timetableLookups.get();
        }
        
        public int getDepartureCacheHits() {
                return departureCacheHits.get();
        }
        
        public int getTimetableCacheHits() {
                return timetableCacheHits.get();
        }
        
        public int getDepartureErrors() {
                return departureErrors.get();
        }
        
        public int getTimetableErrors() {
                return timetableErrors.get();
        }
        
        public Date getLastReset() {
                return lastReset;
        }
        
        
        /* helper functions */
        
        public String getElapsedAsString() {
                Date now = new Date();          
                long duration = (now.getTime() - lastReset.getTime() );
                
                return DurationFormatUtils.formatDuration(duration, "d, HH:mm:ss"); 
        }
        
        public double getElapsedDays() {
                Date now = new Date();          
                long elapsedMs = now.getTime() - lastReset.getTime();
                long elapsedHour = elapsedMs / (60*60*1000);
                
                double elapsedDay = ((double)elapsedHour) / 24.0;
                
                if (elapsedDay < 1.0)
                        elapsedDay  = 1.0;
                
                return elapsedDay;
        }
        
        
        /*******
         * Save stats to DB
         */
        
        public void saveStats() {
                synchronized(this) {
                        int loc = stationLookupsLocation.get();
                        int name = stationLookupsName.get();
                        int fav = stationLookupsFavorites.get();
                        int departure = departureLookups.get();
                        int depcache = departureCacheHits.get();
                        int deperror = departureErrors.get();
                        int timetable = timetableLookups.get();
                        int timecache = timetableCacheHits.get();
                        int timeerror = timetableErrors.get();
                        
                        int diff_loc = loc - old_stationLookupsLocation;
                        int diff_name = name - old_stationLookupsName;
                        int diff_fav = fav - old_stationLookupsFavorites;
                        
                        int diff_departure = departure - old_departureLookups;
                        int diff_depcache = depcache - old_departureCacheHits;
                        int diff_deperror = deperror - old_departureErrors;                     
                        
                        int diff_timetable = timetable - old_timetableLookups;                  
                        int diff_timecache = timecache - old_timetableCacheHits;                        
                        int diff_timeerror = timeerror - old_timetableErrors;
                        
                        if ( diff_loc != 0 || diff_name != 0 || diff_fav != 0 ||
                                        diff_departure != 0 || diff_timetable != 0 || diff_depcache != 0 || diff_timecache != 0 ||
                                        diff_deperror != 0 || diff_timeerror != 0) {
                                try {

                                        //System.out.println("Updating ...");
                                        Connection conn = DBConnection.getConnection();
                                        PreparedStatement stmt = conn.prepareStatement("UPDATE trainstatistics SET location=location+?, name=name+?, favorites=favorites+?, departure=departure+?, " + 
                                                        "depcache=depcache+?, deperror=deperror+?, timetable=timetable+?, timecache=timecache+?, timeerror=timeerror+? " + 
                                                        "WHERE statisticsdate=now()::date");
                                        
                                        stmt.setInt(1, diff_loc);
                                        stmt.setInt(2, diff_name);
                                        stmt.setInt(3, diff_fav);
                                        stmt.setInt(4, diff_departure);
                                        stmt.setInt(5, diff_depcache);
                                        stmt.setInt(6, diff_deperror);
                                        stmt.setInt(7, diff_timetable);
                                        stmt.setInt(8, diff_timecache);
                                        stmt.setInt(9, diff_timeerror);
                                        
                                        int rowcount = stmt.executeUpdate();
                                        
                                        stmt.close();
                                        
                                        if (rowcount == 0) {
                                                
                                                //System.out.println("inserting new row ...");
                                                stmt = conn.prepareStatement("INSERT INTO trainstatistics(statisticsdate,location,name,favorites,departure,depcache,deperror,timetable,timecache,timeerror) " +
                                                                "values (now()::date, ?,?,?,?,?,?,?,?,?)" );
                                                
                                                stmt.setInt(1, diff_loc);
                                                stmt.setInt(2, diff_name);
                                                stmt.setInt(3, diff_fav);
                                                stmt.setInt(4, diff_departure);
                                                stmt.setInt(5, diff_depcache);
                                                stmt.setInt(6, diff_deperror);
                                                stmt.setInt(7, diff_timetable);
                                                stmt.setInt(8, diff_timecache);
                                                stmt.setInt(9, diff_timeerror);                                 
                                                
                                                stmt.executeUpdate();
                                        }
                                        
                                        
                                        old_stationLookupsLocation = loc;
                                        old_stationLookupsName = name;
                                        old_stationLookupsFavorites = fav;
                                        old_departureLookups = departure;
                                        old_departureCacheHits = depcache;      
                                        old_departureErrors = deperror;
                                        old_timetableLookups = timetable;       
                                        old_timetableCacheHits = timecache;
                                        old_timetableErrors = timeerror;
                                        
                                        conn.close();
                                        

                                } catch (SQLException sqle) {
                                        
                                }
                        }
                                                
                }
        }
        
        /*******
         * Singleton stuff
         */
        
        private static Statistics instance = null;
        private Statistics() {
                // Exists only to defeat instantiation.
        }
        public static Statistics getInstance() {
                if(instance == null) {
                        instance = new Statistics();
                }
                return instance;
        }
}
1	package dk.thoerup.traininfoservice;
2
3	import java.sql.Connection;
4	import java.sql.PreparedStatement;
5	import java.sql.SQLException;
6	import java.util.Date;
7	import java.util.concurrent.atomic.AtomicInteger;
8
9	import org.apache.commons.lang.time.DurationFormatUtils;
10
11	public class Statistics {
12
13	private AtomicInteger stationLookupsLocation = new AtomicInteger(0);
14	private AtomicInteger stationLookupsName = new AtomicInteger(0);
15	private AtomicInteger stationLookupsFavorites = new AtomicInteger(0);
16	private AtomicInteger departureLookups = new AtomicInteger(0);
17	private AtomicInteger timetableLookups = new AtomicInteger(0);
18	private AtomicInteger departureCacheHits = new AtomicInteger(0);
19	private AtomicInteger timetableCacheHits = new AtomicInteger(0);
20	private AtomicInteger departureErrors = new AtomicInteger(0);
21	private AtomicInteger timetableErrors = new AtomicInteger(0);
22
23	private int old_stationLookupsLocation = 0;
24	private int old_stationLookupsName = 0;
25	private int old_stationLookupsFavorites = 0;
26	private int old_departureLookups = 0;
27	private int old_timetableLookups = 0;
28	private int old_departureCacheHits = 0;
29	private int old_timetableCacheHits = 0;
30	private int old_departureErrors = 0;
31	private int old_timetableErrors = 0;
32
33	private Date lastReset = new Date();
34
35	public void incrementStationLookupsLocation() {
36	stationLookupsLocation.incrementAndGet();
37	}
38
39	public void incrementStationLookupsName() {
40	stationLookupsName.incrementAndGet();
41	}
42
43	public void incrementStationLookupsFavorites() {
44	stationLookupsFavorites.incrementAndGet();
45	}
46
47	public void incrementDepartureLookups() {
48	departureLookups.incrementAndGet();
49	}
50
51	public void incrementTimetableLookups() {
52	timetableLookups.incrementAndGet();
53	}
54
55	public void incrementDepartureCacheHits() {
56	departureCacheHits.incrementAndGet();
57	}
58
59	public void incrementTimetableCacheHits() {
60	timetableCacheHits.incrementAndGet();
61	}
62
63	public void incrementDepartureErrors() {
64	departureErrors.incrementAndGet();
65	}
66
67	public void incrementTimetableErrors() {
68	timetableErrors.incrementAndGet();
69	}
70
71	/////////
72
73	public int getStationTotals() {
74	return stationLookupsLocation.get() + stationLookupsName.get() + stationLookupsFavorites.get();
75	}
76
77	public int getStationLookupsLocation() {
78	return stationLookupsLocation.get();
79	}
80
81	public int getStationLookupsName() {
82	return stationLookupsName.get();
83	}
84
85	public int getStationLookupsFavorites() {
86	return stationLookupsFavorites.get();
87	}
88
89	public int getDepartureLookups() {
90	return departureLookups.get();
91	}
92
93	public int getTimetableLookups() {
94	return timetableLookups.get();
95	}
96
97	public int getDepartureCacheHits() {
98	return departureCacheHits.get();
99	}
100
101	public int getTimetableCacheHits() {
102	return timetableCacheHits.get();
103	}
104
105	public int getDepartureErrors() {
106	return departureErrors.get();
107	}
108
109	public int getTimetableErrors() {
110	return timetableErrors.get();
111	}
112
113	public Date getLastReset() {
114	return lastReset;
115	}
116
117
118	/* helper functions */
119
120	public String getElapsedAsString() {
121	Date now = new Date();
122	long duration = (now.getTime() - lastReset.getTime() );
123
124	return DurationFormatUtils.formatDuration(duration, "d, HH:mm:ss");
125	}
126
127	public double getElapsedDays() {
128	Date now = new Date();
129	long elapsedMs = now.getTime() - lastReset.getTime();
130	long elapsedHour = elapsedMs / (60601000);
131
132	double elapsedDay = ((double)elapsedHour) / 24.0;
133
134	if (elapsedDay < 1.0)
135	elapsedDay = 1.0;
136
137	return elapsedDay;
138	}
139
140
141	/*******
142	* Save stats to DB
143	*/
144
145	public void saveStats() {
146	synchronized(this) {
147	int loc = stationLookupsLocation.get();
148	int name = stationLookupsName.get();
149	int fav = stationLookupsFavorites.get();
150	int departure = departureLookups.get();
151	int depcache = departureCacheHits.get();
152	int deperror = departureErrors.get();
153	int timetable = timetableLookups.get();
154	int timecache = timetableCacheHits.get();
155	int timeerror = timetableErrors.get();
156
157	int diff_loc = loc - old_stationLookupsLocation;
158	int diff_name = name - old_stationLookupsName;
159	int diff_fav = fav - old_stationLookupsFavorites;
160
161	int diff_departure = departure - old_departureLookups;
162	int diff_depcache = depcache - old_departureCacheHits;
163	int diff_deperror = deperror - old_departureErrors;
164
165	int diff_timetable = timetable - old_timetableLookups;
166	int diff_timecache = timecache - old_timetableCacheHits;
167	int diff_timeerror = timeerror - old_timetableErrors;
168
169	if ( diff_loc != 0 \|\| diff_name != 0 \|\| diff_fav != 0 \|\|
170	diff_departure != 0 \|\| diff_timetable != 0 \|\| diff_depcache != 0 \|\| diff_timecache != 0 \|\|
171	diff_deperror != 0 \|\| diff_timeerror != 0) {
172	try {
173
174	//System.out.println("Updating ...");
175	Connection conn = DBConnection.getConnection();
176	PreparedStatement stmt = conn.prepareStatement("UPDATE trainstatistics SET location=location+?, name=name+?, favorites=favorites+?, departure=departure+?, " +
177	"depcache=depcache+?, deperror=deperror+?, timetable=timetable+?, timecache=timecache+?, timeerror=timeerror+? " +
178	"WHERE statisticsdate=now()::date");
179
180	stmt.setInt(1, diff_loc);
181	stmt.setInt(2, diff_name);
182	stmt.setInt(3, diff_fav);
183	stmt.setInt(4, diff_departure);
184	stmt.setInt(5, diff_depcache);
185	stmt.setInt(6, diff_deperror);
186	stmt.setInt(7, diff_timetable);
187	stmt.setInt(8, diff_timecache);
188	stmt.setInt(9, diff_timeerror);
189
190	int rowcount = stmt.executeUpdate();
191
192	stmt.close();
193
194	if (rowcount == 0) {
195
196	//System.out.println("inserting new row ...");
197	stmt = conn.prepareStatement("INSERT INTO trainstatistics(statisticsdate,location,name,favorites,departure,depcache,deperror,timetable,timecache,timeerror) " +
198	"values (now()::date, ?,?,?,?,?,?,?,?,?)" );
199
200	stmt.setInt(1, diff_loc);
201	stmt.setInt(2, diff_name);
202	stmt.setInt(3, diff_fav);
203	stmt.setInt(4, diff_departure);
204	stmt.setInt(5, diff_depcache);
205	stmt.setInt(6, diff_deperror);
206	stmt.setInt(7, diff_timetable);
207	stmt.setInt(8, diff_timecache);
208	stmt.setInt(9, diff_timeerror);
209
210	stmt.executeUpdate();
211	}
212
213
214	old_stationLookupsLocation = loc;
215	old_stationLookupsName = name;
216	old_stationLookupsFavorites = fav;
217	old_departureLookups = departure;
218	old_departureCacheHits = depcache;
219	old_departureErrors = deperror;
220	old_timetableLookups = timetable;
221	old_timetableCacheHits = timecache;
222	old_timetableErrors = timeerror;
223
224	conn.close();
225
226
227	} catch (SQLException sqle) {
228
229	}
230	}
231
232	}
233	}
234
235	/*******
236	* Singleton stuff
237	*/
238
239	private static Statistics instance = null;
240	private Statistics() {
241	// Exists only to defeat instantiation.
242	}
243	public static Statistics getInstance() {
244	if(instance == null) {
245	instance = new Statistics();
246	}
247	return instance;
248	}
249	}