KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > go > trove > util > tq > TransactionQueueData


1 /* ====================================================================
2  * Trove - Copyright (c) 1997-2000 Walt Disney Internet Group
3  * ====================================================================
4  * The Tea Software License, Version 1.1
5  *
6  * Copyright (c) 2000 Walt Disney Internet Group. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in
17  * the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * 3. The end-user documentation included with the redistribution,
21  * if any, must include the following acknowledgment:
22  * "This product includes software developed by the
23  * Walt Disney Internet Group (http://opensource.go.com/)."
24  * Alternately, this acknowledgment may appear in the software itself,
25  * if and wherever such third-party acknowledgments normally appear.
26  *
27  * 4. The names "Tea", "TeaServlet", "Kettle", "Trove" and "BeanDoc" must
28  * not be used to endorse or promote products derived from this
29  * software without prior written permission. For written
30  * permission, please contact opensource@dig.com.
31  *
32  * 5. Products derived from this software may not be called "Tea",
33  * "TeaServlet", "Kettle" or "Trove", nor may "Tea", "TeaServlet",
34  * "Kettle", "Trove" or "BeanDoc" appear in their name, without prior
35  * written permission of the Walt Disney Internet Group.
36  *
37  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40  * DISCLAIMED. IN NO EVENT SHALL THE WALT DISNEY INTERNET GROUP OR ITS
41  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
42  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
43  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
44  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
45  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
47  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48  * ====================================================================
49  *
50  * For more information about Tea, please see http://opensource.go.com/.
51  */

52
53 package com.go.trove.util.tq;
54
55 import java.util.Date JavaDoc;
56
57 /******************************************************************************
58  * This class contains a snapshot of data from a {@link TransactionQueue}.
59  *
60  * @author Brian S O'Neill
61  * @version
62  * <!--$$Revision:--> 17 <!-- $-->, <!--$$JustDate:--> 01/03/13 <!-- $-->
63  */

64 public class TransactionQueueData implements java.io.Serializable JavaDoc {
65     private transient final TransactionQueue mTransactionQueue;
66
67     private final long mSnapshotStart;
68     private final long mSnapshotEnd;
69     private final int mQueueSize;
70     private final int mThreadCount;
71     private final int mServicingCount;
72     private final int mPeakQueueSize;
73     private final int mPeakThreadCount;
74     private final int mPeakServicingCount;
75     private final int mTotalEnqueueAttempts;
76     private final int mTotalEnqueued;
77     private final int mTotalServiced;
78     private final int mTotalExpired;
79     private final int mTotalServiceExceptions;
80     private final int mTotalUncaughtExceptions;
81     private final long mTotalQueueDuration;
82     private final long mTotalServiceDuration;
83
84     private transient Date JavaDoc mStartDate;
85     private transient Date JavaDoc mEndDate;
86
87     TransactionQueueData(TransactionQueue tq,
88                          long snapshotStart,
89                          long snapshotEnd,
90                          int queueSize,
91                          int threadCount,
92                          int servicingCount,
93                          int peakQueueSize,
94                          int peakThreadCount,
95                          int peakServicingCount,
96                          int totalEnqueueAttempts,
97                          int totalEnqueued,
98                          int totalServiced,
99                          int totalExpired,
100                          int totalServiceExceptions,
101                          int totalUncaughtExceptions,
102                          long totalQueueDuration,
103                          long totalServiceDuration) {
104
105         mTransactionQueue = tq;
106         mSnapshotStart = snapshotStart;
107         mSnapshotEnd = snapshotEnd;
108         mQueueSize = queueSize;
109         mThreadCount = threadCount;
110         mServicingCount = servicingCount;
111         mPeakQueueSize = peakQueueSize;
112         mPeakThreadCount = peakThreadCount;
113         mPeakServicingCount = peakServicingCount;
114         mTotalEnqueueAttempts = totalEnqueueAttempts;
115         mTotalEnqueued = totalEnqueued;
116         mTotalServiced = totalServiced;
117         mTotalExpired = totalExpired;
118         mTotalServiceExceptions = totalServiceExceptions;
119         mTotalUncaughtExceptions = totalUncaughtExceptions;
120         mTotalQueueDuration = totalQueueDuration;
121         mTotalServiceDuration = totalServiceDuration;
122     }
123
124     /**
125      * Adds TransactionQueueData to another.
126      */

127     public TransactionQueueData add(TransactionQueueData data) {
128         return new TransactionQueueData
129             (null,
130              Math.min(mSnapshotStart, data.mSnapshotStart),
131              Math.max(mSnapshotEnd, data.mSnapshotEnd),
132              mQueueSize + data.mQueueSize,
133              mThreadCount + data.mThreadCount,
134              mServicingCount + data.mServicingCount,
135              Math.max(mPeakQueueSize, data.mPeakQueueSize),
136              Math.max(mPeakThreadCount, data.mPeakThreadCount),
137              Math.max(mPeakServicingCount, data.mPeakServicingCount),
138              mTotalEnqueueAttempts + data.mTotalEnqueueAttempts,
139              mTotalEnqueued + data.mTotalEnqueued,
140              mTotalServiced + data.mTotalServiced,
141              mTotalExpired + data.mTotalExpired,
142              mTotalServiceExceptions + data.mTotalServiceExceptions,
143              mTotalUncaughtExceptions + data.mTotalUncaughtExceptions,
144              mTotalQueueDuration + data.mTotalQueueDuration,
145              mTotalServiceDuration + data.mTotalServiceDuration
146              );
147     }
148
149     /**
150      * Returns the TransactionQueue source of this data, or null if not
151      * applicable or missing.
152      */

153     public TransactionQueue getTransactionQueue() {
154         return mTransactionQueue;
155     }
156
157     /**
158      * Returns the date/time for when the snapshot started.
159      */

160     public Date JavaDoc getSnapshotStart() {
161         if (mStartDate == null) {
162             mStartDate = new Date JavaDoc(mSnapshotStart);
163         }
164         return mStartDate;
165     }
166
167     /**
168      * Returns the date/time for when the snapshot ended.
169      */

170     public Date JavaDoc getSnapshotEnd() {
171         if (mEndDate == null) {
172             mEndDate = new Date JavaDoc(mSnapshotEnd);
173         }
174         return mEndDate;
175     }
176
177     /**
178      * Returns the number of queued transactions at the snapshot end.
179      */

180     public int getQueueSize() {
181         return mQueueSize;
182     }
183
184     /**
185      * Returns the amount of worker threads in this TransactionQueue at the
186      * snapshot end.
187      */

188     public int getThreadCount() {
189         return mThreadCount;
190     }
191
192     /**
193      * Returns the amount of transactions currently being serviced at the
194      * snapshot end.
195      */

196     public int getServicingCount() {
197         return mServicingCount;
198     }
199
200     /**
201      * Returns the biggest queue size over the snapshot interval.
202      */

203     public int getPeakQueueSize() {
204         return mPeakQueueSize;
205     }
206
207     /**
208      * Returns the highest thread count over the snapshot interval.
209      */

210     public int getPeakThreadCount() {
211         return mPeakThreadCount;
212     }
213
214     /**
215      * Returns the highest servicing count over the snapshot interval.
216      */

217     public int getPeakServicingCount() {
218         return mPeakServicingCount;
219     }
220
221     /**
222      * Returns the total amount of transactions that were attempted to be
223      * enqueued over the snapshot interval.
224      */

225     public int getTotalEnqueueAttempts() {
226         return mTotalEnqueueAttempts;
227     }
228
229     /**
230      * Returns the total amount of transactions that were enqueued over the
231      * snapshot interval.
232      */

233     public int getTotalEnqueued() {
234         return mTotalEnqueued;
235     }
236
237     /**
238      * Returns the total amount of transactions serviced over the snapshot
239      * interval.
240      */

241     public int getTotalServiced() {
242         return mTotalServiced;
243     }
244
245     /**
246      * Returns the total amount of expired transactions over the snapshot
247      * interval.
248      */

249     public int getTotalExpired() {
250         return mTotalExpired;
251     }
252
253     /**
254      * Returns the number of transactions that were canceled because of an
255      * uncaught exception while being serviced.
256      */

257     public int getTotalServiceExceptions() {
258         return mTotalServiceExceptions;
259     }
260
261     /**
262      * Returns the total number of uncaught exceptions in the TransactionQueue.
263      * This value is usually the same as the total number of service
264      * exceptions. If it is larger, this does necessarily not indicate that the
265      * TransactionQueue has an internal error because exceptions can be
266      * generated while attempting to cancel a transaction.
267      */

268     public int getTotalUncaughtExceptions() {
269         return mTotalUncaughtExceptions;
270     }
271
272     /**
273      * Returns the total time, in milliseconds, that transactions were
274      * waiting in the queue.
275      */

276     public long getTotalQueueDuration() {
277         return mTotalQueueDuration;
278     }
279
280     /**
281      * Returns the total time, in milliseconds, that transactions were being
282      * serviced.
283      */

284     public long getTotalServiceDuration() {
285         return mTotalServiceDuration;
286     }
287
288     // Calculated data.
289

290     /**
291      * Returns the length of the snapshot interval in milliseconds.
292      */

293     public long getSnapshotDuration() {
294         return mSnapshotEnd - mSnapshotStart;
295     }
296
297     /**
298      * Returns the total amount of enqueue attempts that failed because the
299      * queue was full.
300      */

301     public int getTotalEnqueueFailures() {
302         return mTotalEnqueueAttempts - mTotalEnqueued;
303     }
304
305     /**
306      * Returns the total amount of transactions that weren't serviced because
307      * the queue was full, the transaction expired, or an exception was thrown.
308      */

309     public int getTotalUnserviced() {
310         return getTotalEnqueueFailures() +
311             mTotalExpired + mTotalServiceExceptions;
312     }
313
314     /**
315      * Returns the average amount of time, in milliseconds, that a
316      * transaction was in the queue.
317      */

318     public double getAverageQueueDuration() {
319         return ((double)getTotalQueueDuration()) /
320             ((double)getTotalEnqueued());
321     }
322
323     /**
324      * Returns the average amount of time, in milliseconds, it took servicing
325      * a transaction.
326      */

327     public double getAverageServiceDuration() {
328         return ((double)getTotalServiceDuration()) /
329             ((double)getTotalServiced());
330     }
331
332     /**
333      * Returns the amount of enqueue attempts per second over the snapshot
334      * interval.
335      */

336     public double getEnqueueAttemptRate() {
337         return ((double)getTotalEnqueueAttempts() * 1000) /
338             ((double)getSnapshotDuration());
339     }
340
341     /**
342      * Returns the amount of successful transaction enqueues per second over
343      * the snapshot interval.
344      */

345     public double getEnqueueSuccessRate() {
346         return ((double)getTotalEnqueued() * 1000) /
347             ((double)getSnapshotDuration());
348     }
349
350     /**
351      * Returns the amount of transactions serviced per second over the
352      * snapshot interval.
353      */

354     public double getServiceRate() {
355         return ((double)getTotalServiced() * 1000) /
356             ((double)getSnapshotDuration());
357     }
358
359     /**
360      * Returns zero if no enqueues failed, one if all enqueues failed, or
361      * a number in between if some failed.
362      */

363     public double getEnqueueFailureRatio() {
364         return 1.0d - ((double)getTotalEnqueued()) /
365             ((double)getTotalEnqueueAttempts());
366     }
367 }
368
Popular Tags