001    /*
002     * Copyright 2008-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2015 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.ldap.sdk.unboundidds.monitors;
022    
023    
024    
025    import java.util.Collections;
026    import java.util.Iterator;
027    import java.util.LinkedHashMap;
028    import java.util.Map;
029    
030    import com.unboundid.ldap.sdk.Entry;
031    import com.unboundid.util.NotExtensible;
032    import com.unboundid.util.NotMutable;
033    import com.unboundid.util.ThreadSafety;
034    import com.unboundid.util.ThreadSafetyLevel;
035    
036    import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
037    import static com.unboundid.util.Debug.*;
038    
039    
040    
041    /**
042     * <BLOCKQUOTE>
043     *   <B>NOTE:</B>  This class is part of the Commercial Edition of the UnboundID
044     *   LDAP SDK for Java.  It is not available for use in applications that
045     *   include only the Standard Edition of the LDAP SDK, and is not supported for
046     *   use in conjunction with non-UnboundID products.
047     * </BLOCKQUOTE>
048     * This class defines a monitor entry that provides information about the
049     * processing times of operations that are performed in the server.  It includes
050     * the total counts of each type of operation, the average response time for
051     * each type of operation, and counts and percentages of operations whose
052     * server-side processing time fits in defined buckets.  The following buckets
053     * are defined in the default configuration:
054     * <UL>
055     *   <LI>Less than 1ms.</LI>
056     *   <LI>Greater than or equal to 1ms and less than 2ms.</LI>
057     *   <LI>Greater than or equal to 2ms and less than 3ms.</LI>
058     *   <LI>Greater than or equal to 3ms and less than 5ms.</LI>
059     *   <LI>Greater than or equal to 5ms and less than 10ms.</LI>
060     *   <LI>Greater than or equal to 10ms and less than 20ms.</LI>
061     *   <LI>Greater than or equal to 20ms and less than 30ms.</LI>
062     *   <LI>Greater than or equal to 30ms and less than 50ms.</LI>
063     *   <LI>Greater than or equal to 50ms and less than 100ms.</LI>
064     *   <LI>Greater than or equal to 100ms and less than 1000ms.</LI>
065     *   <LI>Greater than or equal to 1000ms.</LI>
066     * </UL>
067     * It provides the following information for each operation, as well as for the
068     * total for all operations:
069     * <UL>
070     *   <LI>The number of operations of the specified type within each bucket.</LI>
071     *   <LI>The percentage of operations of the specified type within each
072     *       bucket.</LI>
073     *   <LI>The aggregate percentage of operations of the specified type for each
074     *        bucket (i.e., the percentage of operations in that bucket or any
075     *        bucket for a lower duration).</LI>
076     * </UL>
077     * The server should present at most one processing time histogram monitor
078     * entry.  It can be retrieved using the
079     * {@link MonitorManager#getProcessingTimeHistogramMonitorEntry} method.
080     * This entry provides specific methods for accessing information about
081     * processing times per bucket (e.g., the
082     * {@link ProcessingTimeHistogramMonitorEntry#getAllOpsPercent} method can be
083     * used to retrieve a map containing the percent of operations within each
084     * bucket).  Alternately, this information may be accessed using the generic
085     * API.  See the {@link MonitorManager} class documentation for an example that
086     * demonstrates the use of the generic API for accessing monitor data.
087     */
088    @NotMutable()
089    @NotExtensible()
090    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
091    public class ProcessingTimeHistogramMonitorEntry
092           extends MonitorEntry
093    {
094      /**
095       * The structural object class used in processing time histogram monitor
096       * entries.
097       */
098      static final String PROCESSING_TIME_HISTOGRAM_MONITOR_OC =
099           "ds-processing-time-histogram-monitor-entry";
100    
101    
102    
103      /**
104       * The name of the attribute that contains the total number of add
105       * operations performed in the server.
106       */
107      private static final String ATTR_ADD_TOTAL_COUNT = "addOpsTotalCount";
108    
109    
110    
111      /**
112       * The name of the attribute that contains the average response time in
113       * milliseconds for add operations performed in the server.
114       */
115      private static final String ATTR_ADD_AVERAGE_RESPONSE_TIME_MS =
116           "addOpsAverageResponseTimeMillis";
117    
118    
119    
120      /**
121       * The name of the attribute that contains the aggregate percentage of add
122       * operations within each processing time bucket.
123       */
124      private static final String ATTR_ADD_AGGREGATE_PERCENT =
125           "addOpsAggregatePercent";
126    
127    
128    
129      /**
130       * The name of the attribute that contains the total number of add operations
131       * within each processing time bucket.
132       */
133      private static final String ATTR_ADD_COUNT = "addOpsCount";
134    
135    
136    
137      /**
138       * The name of the attribute that contains the percentage of add operations
139       * within each processing time bucket.
140       */
141      private static final String ATTR_ADD_PERCENT = "addOpsPercent";
142    
143    
144    
145      /**
146       * The name of the attribute that contains the total number of all
147       * operations performed in the server.
148       */
149      private static final String ATTR_ALL_TOTAL_COUNT = "allOpsTotalCount";
150    
151    
152    
153      /**
154       * The name of the attribute that contains the average response time in
155       * milliseconds for all operations performed in the server.
156       */
157      private static final String ATTR_ALL_AVERAGE_RESPONSE_TIME_MS =
158           "allOpsAverageResponseTimeMillis";
159    
160    
161    
162      /**
163       * The name of the attribute that contains the aggregate percentage of
164       * operations of all types within each processing time bucket.
165       */
166      private static final String ATTR_ALL_AGGREGATE_PERCENT =
167           "allOpsAggregatePercent";
168    
169    
170    
171      /**
172       * The name of the attribute that contains the total number of operations of
173       * all types within each processing time bucket.
174       */
175      private static final String ATTR_ALL_COUNT = "allOpsCount";
176    
177    
178    
179      /**
180       * The name of the attribute that contains the percentage of operations of all
181       * types within each processing time bucket.
182       */
183      private static final String ATTR_ALL_PERCENT = "allOpsPercent";
184    
185    
186    
187      /**
188       * The name of the attribute that contains the total number of bind
189       * operations performed in the server.
190       */
191      private static final String ATTR_BIND_TOTAL_COUNT = "bindOpsTotalCount";
192    
193    
194    
195      /**
196       * The name of the attribute that contains the average response time in
197       * milliseconds for bind operations performed in the server.
198       */
199      private static final String ATTR_BIND_AVERAGE_RESPONSE_TIME_MS =
200           "bindOpsAverageResponseTimeMillis";
201    
202    
203    
204      /**
205       * The name of the attribute that contains the aggregate percentage of bind
206       * operations within each processing time bucket.
207       */
208      private static final String ATTR_BIND_AGGREGATE_PERCENT =
209           "bindOpsAggregatePercent";
210    
211    
212    
213      /**
214       * The name of the attribute that contains the total number of bind operations
215       * within each processing time bucket.
216       */
217      private static final String ATTR_BIND_COUNT = "bindOpsCount";
218    
219    
220    
221      /**
222       * The name of the attribute that contains the percentage of bind operations
223       * within each processing time bucket.
224       */
225      private static final String ATTR_BIND_PERCENT = "bindOpsPercent";
226    
227    
228    
229      /**
230       * The name of the attribute that contains the total number of compare
231       * operations performed in the server.
232       */
233      private static final String ATTR_COMPARE_TOTAL_COUNT = "compareOpsTotalCount";
234    
235    
236    
237      /**
238       * The name of the attribute that contains the average response time in
239       * milliseconds for compare operations performed in the server.
240       */
241      private static final String ATTR_COMPARE_AVERAGE_RESPONSE_TIME_MS =
242           "compareOpsAverageResponseTimeMillis";
243    
244    
245    
246      /**
247       * The name of the attribute that contains the aggregate percentage of compare
248       * operations within each processing time bucket.
249       */
250      private static final String ATTR_COMPARE_AGGREGATE_PERCENT =
251           "compareOpsAggregatePercent";
252    
253    
254    
255      /**
256       * The name of the attribute that contains the total number of compare
257       * operations within each processing time bucket.
258       */
259      private static final String ATTR_COMPARE_COUNT = "compareOpsCount";
260    
261    
262    
263      /**
264       * The name of the attribute that contains the percentage of compare
265       * operations within each processing time bucket.
266       */
267      private static final String ATTR_COMPARE_PERCENT = "compareOpsPercent";
268    
269    
270    
271      /**
272       * The name of the attribute that contains the total number of delete
273       * operations performed in the server.
274       */
275      private static final String ATTR_DELETE_TOTAL_COUNT = "deleteOpsTotalCount";
276    
277    
278    
279      /**
280       * The name of the attribute that contains the average response time in
281       * milliseconds for delete operations performed in the server.
282       */
283      private static final String ATTR_DELETE_AVERAGE_RESPONSE_TIME_MS =
284           "deleteOpsAverageResponseTimeMillis";
285    
286    
287    
288      /**
289       * The name of the attribute that contains the aggregate percentage of delete
290       * operations within each processing time bucket.
291       */
292      private static final String ATTR_DELETE_AGGREGATE_PERCENT =
293           "deleteOpsAggregatePercent";
294    
295    
296    
297      /**
298       * The name of the attribute that contains the total number of delete
299       * operations within each processing time bucket.
300       */
301      private static final String ATTR_DELETE_COUNT = "deleteOpsCount";
302    
303    
304    
305      /**
306       * The name of the attribute that contains the percentage of delete operations
307       * within each processing time bucket.
308       */
309      private static final String ATTR_DELETE_PERCENT = "deleteOpsPercent";
310    
311    
312    
313      /**
314       * The name of the attribute that contains the total number of extended
315       * operations performed in the server.
316       */
317      private static final String ATTR_EXTENDED_TOTAL_COUNT =
318           "extendedOpsTotalCount";
319    
320    
321    
322      /**
323       * The name of the attribute that contains the average response time in
324       * milliseconds for extended operations performed in the server.
325       */
326      private static final String ATTR_EXTENDED_AVERAGE_RESPONSE_TIME_MS =
327           "extendedOpsAverageResponseTimeMillis";
328    
329    
330    
331      /**
332       * The name of the attribute that contains the aggregate percentage of
333       * extended operations within each processing time bucket.
334       */
335      private static final String ATTR_EXTENDED_AGGREGATE_PERCENT =
336           "extendedOpsAggregatePercent";
337    
338    
339    
340      /**
341       * The name of the attribute that contains the total number of extended
342       * operations within each processing time bucket.
343       */
344      private static final String ATTR_EXTENDED_COUNT = "extendedOpsCount";
345    
346    
347    
348      /**
349       * The name of the attribute that contains the percentage of extended
350       * operations within each processing time bucket.
351       */
352      private static final String ATTR_EXTENDED_PERCENT = "extendedOpsPercent";
353    
354    
355    
356      /**
357       * The name of the attribute that contains the total number of modify
358       * operations performed in the server.
359       */
360      private static final String ATTR_MODIFY_TOTAL_COUNT = "modifyOpsTotalCount";
361    
362    
363    
364      /**
365       * The name of the attribute that contains the average response time in
366       * milliseconds for modify operations performed in the server.
367       */
368      private static final String ATTR_MODIFY_AVERAGE_RESPONSE_TIME_MS =
369           "modifyOpsAverageResponseTimeMillis";
370    
371    
372    
373      /**
374       * The name of the attribute that contains the aggregate percentage of modify
375       * operations within each processing time bucket.
376       */
377      private static final String ATTR_MODIFY_AGGREGATE_PERCENT =
378           "modifyOpsAggregatePercent";
379    
380    
381    
382      /**
383       * The name of the attribute that contains the total number of modify
384       * operations within each processing time bucket.
385       */
386      private static final String ATTR_MODIFY_COUNT = "modifyOpsCount";
387    
388    
389    
390      /**
391       * The name of the attribute that contains the percentage of modify operations
392       * within each processing time bucket.
393       */
394      private static final String ATTR_MODIFY_PERCENT = "modifyOpsPercent";
395    
396    
397    
398      /**
399       * The name of the attribute that contains the total number of modify DN
400       * operations performed in the server.
401       */
402      private static final String ATTR_MODIFY_DN_TOTAL_COUNT =
403           "modifyDNOpsTotalCount";
404    
405    
406    
407      /**
408       * The name of the attribute that contains the average response time in
409       * milliseconds for modify DN operations performed in the server.
410       */
411      private static final String ATTR_MODIFY_DN_AVERAGE_RESPONSE_TIME_MS =
412           "modifyDNOpsAverageResponseTimeMillis";
413    
414    
415    
416      /**
417       * The name of the attribute that contains the aggregate percentage of modify
418       * DN operations within each processing time bucket.
419       */
420      private static final String ATTR_MODIFY_DN_AGGREGATE_PERCENT =
421           "modifyDNOpsAggregatePercent";
422    
423    
424    
425      /**
426       * The name of the attribute that contains the total number of modify DN
427       * operations within each processing time bucket.
428       */
429      private static final String ATTR_MODIFY_DN_COUNT = "modifyDNOpsCount";
430    
431    
432    
433      /**
434       * The name of the attribute that contains the percentage of modify DN
435       * operations within each processing time bucket.
436       */
437      private static final String ATTR_MODIFY_DN_PERCENT = "modifyDNOpsPercent";
438    
439    
440    
441      /**
442       * The name of the attribute that contains the total number of search
443       * operations performed in the server.
444       */
445      private static final String ATTR_SEARCH_TOTAL_COUNT = "searchOpsTotalCount";
446    
447    
448    
449      /**
450       * The name of the attribute that contains the average response time in
451       * milliseconds for search operations performed in the server.
452       */
453      private static final String ATTR_SEARCH_AVERAGE_RESPONSE_TIME_MS =
454           "searchOpsAverageResponseTimeMillis";
455    
456    
457    
458      /**
459       * The name of the attribute that contains the aggregate percentage of search
460       * operations within each processing time bucket.
461       */
462      private static final String ATTR_SEARCH_AGGREGATE_PERCENT =
463           "searchOpsAggregatePercent";
464    
465    
466    
467      /**
468       * The name of the attribute that contains the total number of search
469       * operations within each processing time bucket.
470       */
471      private static final String ATTR_SEARCH_COUNT = "searchOpsCount";
472    
473    
474    
475      /**
476       * The name of the attribute that contains the percentage of search operations
477       * within each processing time bucket.
478       */
479      private static final String ATTR_SEARCH_PERCENT = "searchOpsPercent";
480    
481    
482    
483      /**
484       * The serial version UID for this serializable class.
485       */
486      private static final long serialVersionUID = -2498009928344820276L;
487    
488    
489    
490      // The percent of add operations in each bucket.
491      private final Map<Long,Double> addOpsPercent;
492    
493      // The aggregate percent of add operations in each bucket.
494      private final Map<Long,Double> addOpsAggregatePercent;
495    
496      // The percent of operations of all types in each bucket.
497      private final Map<Long,Double> allOpsPercent;
498    
499      // The aggregate percent of operations of all types in each bucket.
500      private final Map<Long,Double> allOpsAggregatePercent;
501    
502      // The percent of bind operations in each bucket.
503      private final Map<Long,Double> bindOpsPercent;
504    
505      // The aggregate percent of bind operations in each bucket.
506      private final Map<Long,Double> bindOpsAggregatePercent;
507    
508      // The percent of compare operations in each bucket.
509      private final Map<Long,Double> compareOpsPercent;
510    
511      // The aggregate percent of compare operations in each bucket.
512      private final Map<Long,Double> compareOpsAggregatePercent;
513    
514      // The percent of delete operations in each bucket.
515      private final Map<Long,Double> deleteOpsPercent;
516    
517      // The aggregate percent of delete operations in each bucket.
518      private final Map<Long,Double> deleteOpsAggregatePercent;
519    
520      // The percent of extended operations in each bucket.
521      private final Map<Long,Double> extendedOpsPercent;
522    
523      // The aggregate percent of extended operations in each bucket.
524      private final Map<Long,Double> extendedOpsAggregatePercent;
525    
526      // The percent of modify operations in each bucket.
527      private final Map<Long,Double> modifyOpsPercent;
528    
529      // The aggregate percent of modify operations in each bucket.
530      private final Map<Long,Double> modifyOpsAggregatePercent;
531    
532      // The percent of modify DN operations in each bucket.
533      private final Map<Long,Double> modifyDNOpsPercent;
534    
535      // The aggregate percent of modify DN operations in each bucket.
536      private final Map<Long,Double> modifyDNOpsAggregatePercent;
537    
538      // The percent of search operations in each bucket.
539      private final Map<Long,Double> searchOpsPercent;
540    
541      // The aggregate percent of search operations in each bucket.
542      private final Map<Long,Double> searchOpsAggregatePercent;
543    
544      // The number of add operations in each bucket.
545      private final Map<Long,Long> addOpsCount;
546    
547      // The number of operations of all types in each bucket.
548      private final Map<Long,Long> allOpsCount;
549    
550      // The number of bind operations in each bucket.
551      private final Map<Long,Long> bindOpsCount;
552    
553      // The number of compare operations in each bucket.
554      private final Map<Long,Long> compareOpsCount;
555    
556      // The number of delete operations in each bucket.
557      private final Map<Long,Long> deleteOpsCount;
558    
559      // The number of extended operations in each bucket.
560      private final Map<Long,Long> extendedOpsCount;
561    
562      // The number of modify operations in each bucket.
563      private final Map<Long,Long> modifyOpsCount;
564    
565      // The number of modifyDN operations in each bucket.
566      private final Map<Long,Long> modifyDNOpsCount;
567    
568      // The number of search operations in each bucket.
569      private final Map<Long,Long> searchOpsCount;
570    
571      // The total number of add operations.
572      private final Long addOpsTotalCount;
573    
574      // The total number of all operations.
575      private final Long allOpsTotalCount;
576    
577      // The total number of bind operations.
578      private final Long bindOpsTotalCount;
579    
580      // The total number of compare operations.
581      private final Long compareOpsTotalCount;
582    
583      // The total number of delete operations.
584      private final Long deleteOpsTotalCount;
585    
586      // The total number of extended operations.
587      private final Long extendedOpsTotalCount;
588    
589      // The total number of modify operations.
590      private final Long modifyOpsTotalCount;
591    
592      // The total number of modify DN operations.
593      private final Long modifyDNOpsTotalCount;
594    
595      // The total number of search operations.
596      private final Long searchOpsTotalCount;
597    
598      // The average response time in milliseconds for add operations.
599    
600      private final Double addOpsAvgResponseTimeMillis;
601    
602      // The average response time in milliseconds for all operations.
603      private final Double allOpsAvgResponseTimeMillis;
604    
605      // The average response time in milliseconds for bind operations.
606      private final Double bindOpsAvgResponseTimeMillis;
607    
608      // The average response time in milliseconds for compare operations.
609      private final Double compareOpsAvgResponseTimeMillis;
610    
611      // The average response time in milliseconds for delete operations.
612      private final Double deleteOpsAvgResponseTimeMillis;
613    
614      // The average response time in milliseconds for extended operations.
615      private final Double extendedOpsAvgResponseTimeMillis;
616    
617      // The average response time in milliseconds for modify operations.
618      private final Double modifyOpsAvgResponseTimeMillis;
619    
620      // The average response time in milliseconds for modify DN operations.
621      private final Double modifyDNOpsAvgResponseTimeMillis;
622    
623      // The average response time in milliseconds for search operations.
624      private final Double searchOpsAvgResponseTimeMillis;
625    
626    
627      /**
628       * Creates a new processing time histogram monitor entry from the provided
629       * entry.
630       *
631       * @param  entry  The entry to be parsed as a processing time histogram
632       *                monitor entry.  It must not be {@code null}.
633       */
634      public ProcessingTimeHistogramMonitorEntry(final Entry entry)
635      {
636        super(entry);
637    
638        allOpsTotalCount = getLong(ATTR_ALL_TOTAL_COUNT);
639        allOpsAvgResponseTimeMillis = getDouble(ATTR_ALL_AVERAGE_RESPONSE_TIME_MS);
640        allOpsCount = parseCountAttribute(entry, ATTR_ALL_COUNT);
641        allOpsPercent = parsePercentAttribute(entry, ATTR_ALL_PERCENT);
642        allOpsAggregatePercent =
643             parsePercentAttribute(entry, ATTR_ALL_AGGREGATE_PERCENT);
644    
645        addOpsTotalCount = getLong(ATTR_ADD_TOTAL_COUNT);
646        addOpsAvgResponseTimeMillis = getDouble(ATTR_ADD_AVERAGE_RESPONSE_TIME_MS);
647        addOpsCount = parseCountAttribute(entry, ATTR_ADD_COUNT);
648        addOpsPercent = parsePercentAttribute(entry, ATTR_ADD_PERCENT);
649        addOpsAggregatePercent =
650             parsePercentAttribute(entry, ATTR_ADD_AGGREGATE_PERCENT);
651    
652        bindOpsTotalCount = getLong(ATTR_BIND_TOTAL_COUNT);
653        bindOpsAvgResponseTimeMillis =
654             getDouble(ATTR_BIND_AVERAGE_RESPONSE_TIME_MS);
655        bindOpsCount = parseCountAttribute(entry, ATTR_BIND_COUNT);
656        bindOpsPercent = parsePercentAttribute(entry, ATTR_BIND_PERCENT);
657        bindOpsAggregatePercent =
658             parsePercentAttribute(entry, ATTR_BIND_AGGREGATE_PERCENT);
659    
660        compareOpsTotalCount = getLong(ATTR_COMPARE_TOTAL_COUNT);
661        compareOpsAvgResponseTimeMillis =
662             getDouble(ATTR_COMPARE_AVERAGE_RESPONSE_TIME_MS);
663        compareOpsCount = parseCountAttribute(entry, ATTR_COMPARE_COUNT);
664        compareOpsPercent = parsePercentAttribute(entry, ATTR_COMPARE_PERCENT);
665        compareOpsAggregatePercent =
666             parsePercentAttribute(entry, ATTR_COMPARE_AGGREGATE_PERCENT);
667    
668        deleteOpsTotalCount = getLong(ATTR_DELETE_TOTAL_COUNT);
669        deleteOpsAvgResponseTimeMillis =
670             getDouble(ATTR_DELETE_AVERAGE_RESPONSE_TIME_MS);
671        deleteOpsCount = parseCountAttribute(entry, ATTR_DELETE_COUNT);
672        deleteOpsPercent = parsePercentAttribute(entry, ATTR_DELETE_PERCENT);
673        deleteOpsAggregatePercent =
674             parsePercentAttribute(entry, ATTR_DELETE_AGGREGATE_PERCENT);
675    
676        extendedOpsTotalCount = getLong(ATTR_EXTENDED_TOTAL_COUNT);
677        extendedOpsAvgResponseTimeMillis =
678             getDouble(ATTR_EXTENDED_AVERAGE_RESPONSE_TIME_MS);
679        extendedOpsCount = parseCountAttribute(entry, ATTR_EXTENDED_COUNT);
680        extendedOpsPercent = parsePercentAttribute(entry, ATTR_EXTENDED_PERCENT);
681        extendedOpsAggregatePercent =
682             parsePercentAttribute(entry, ATTR_EXTENDED_AGGREGATE_PERCENT);
683    
684        modifyOpsTotalCount = getLong(ATTR_MODIFY_TOTAL_COUNT);
685        modifyOpsAvgResponseTimeMillis =
686             getDouble(ATTR_MODIFY_AVERAGE_RESPONSE_TIME_MS);
687        modifyOpsCount = parseCountAttribute(entry, ATTR_MODIFY_COUNT);
688        modifyOpsPercent = parsePercentAttribute(entry, ATTR_MODIFY_PERCENT);
689        modifyOpsAggregatePercent =
690             parsePercentAttribute(entry, ATTR_MODIFY_AGGREGATE_PERCENT);
691    
692        modifyDNOpsTotalCount = getLong(ATTR_MODIFY_DN_TOTAL_COUNT);
693        modifyDNOpsAvgResponseTimeMillis =
694             getDouble(ATTR_MODIFY_DN_AVERAGE_RESPONSE_TIME_MS);
695        modifyDNOpsCount = parseCountAttribute(entry, ATTR_MODIFY_DN_COUNT);
696        modifyDNOpsPercent = parsePercentAttribute(entry, ATTR_MODIFY_DN_PERCENT);
697        modifyDNOpsAggregatePercent =
698             parsePercentAttribute(entry, ATTR_MODIFY_DN_AGGREGATE_PERCENT);
699    
700        searchOpsTotalCount = getLong(ATTR_SEARCH_TOTAL_COUNT);
701        searchOpsAvgResponseTimeMillis =
702             getDouble(ATTR_SEARCH_AVERAGE_RESPONSE_TIME_MS);
703        searchOpsCount = parseCountAttribute(entry, ATTR_SEARCH_COUNT);
704        searchOpsPercent = parsePercentAttribute(entry, ATTR_SEARCH_PERCENT);
705        searchOpsAggregatePercent =
706             parsePercentAttribute(entry, ATTR_SEARCH_AGGREGATE_PERCENT);
707      }
708    
709    
710    
711      /**
712       * Parses the value of a specified attribute to obtain a mapping between the
713       * lower bucket boundary and an integer value.
714       *
715       * @param  entry  The entry containing the data to process.
716       * @param  name   The name of the attribute containing the data to process.
717       *
718       * @return  A map with the parsed information, or an empty map if the
719       *          specified attribute did not exist or could not be parsed.
720       */
721      private static Map<Long,Long> parseCountAttribute(final Entry entry,
722                                                        final String name)
723      {
724        final String[] values = entry.getAttributeValues(name);
725        if ((values == null) || (values.length == 0))
726        {
727          return Collections.emptyMap();
728        }
729    
730        try
731        {
732          final LinkedHashMap<Long,Long> map = new LinkedHashMap<Long,Long>();
733    
734          // FIXME -- Do we need to figure out how to make this
735          // internationalizeable?
736    
737          // The lower bound for the first bucket will always be zero, so just look
738          // for the colon to separate the label from the value.
739          int colonPos = values[0].indexOf(':');
740          map.put(0L, Long.parseLong(values[0].substring(colonPos+1).trim()));
741    
742          // For remaining values, the lower bound will be the number immediately
743          // after "Between " and immediately before "ms".
744          for (int i=1; i < values.length; i++)
745          {
746            final long lowerBound;
747            int msPos = values[i].indexOf("ms ");
748            if (msPos < 0)
749            {
750              // This must be the last value.
751              msPos = values[i].indexOf("ms:");
752              lowerBound = Long.parseLong(values[i].substring(9, msPos));
753            }
754            else
755            {
756              lowerBound = Long.parseLong(values[i].substring(8, msPos));
757            }
758    
759            colonPos = values[i].indexOf(':', msPos);
760            map.put(lowerBound,
761                    Long.parseLong(values[i].substring(colonPos+1).trim()));
762          }
763    
764          return Collections.unmodifiableMap(map);
765        }
766        catch (Exception e)
767        {
768          debugException(e);
769          return Collections.emptyMap();
770        }
771      }
772    
773    
774    
775      /**
776       * Parses the value of a specified attribute to obtain a mapping between the
777       * lower bucket boundary and a floating-point value.
778       *
779       * @param  entry  The entry containing the data to process.
780       * @param  name   The name of the attribute containing the data to process.
781       *
782       * @return  A map with the parsed information, or an empty map if the
783       *          specified attribute did not exist or could not be parsed.
784       */
785      private static Map<Long,Double> parsePercentAttribute(final Entry entry,
786                                                            final String name)
787      {
788        final String[] values = entry.getAttributeValues(name);
789        if ((values == null) || (values.length == 0))
790        {
791          return Collections.emptyMap();
792        }
793    
794        try
795        {
796          final LinkedHashMap<Long,Double> map = new LinkedHashMap<Long,Double>();
797    
798          // FIXME -- Do we need to figure out how to make this
799          // internationalizeable?
800    
801          // The standard percent histogram attributes will always use the following
802          // pattern:
803          // - One "Less than Xms: N.NNNN%" line.
804          // - Zero or more "Between Xms and Yms: N.NNNN%" lines.
805          // - One "At least Xms: N.NNNN%" line.
806          //
807          // The aggregate percent histogram attributes may use the above pattern,
808          // or they may instead use the following alternate pattern (which will
809          // have one less value because the last aggregate percent is known to be
810          // 100% and will be implied rather than explicitly stated):
811          // - One or more "Less than Xms: N.NNNN%" lines.
812          //
813          // We need to support both formats.
814          boolean atLeastFound = false;
815          long lastUpperBound = 0L;
816          for (final String s : values)
817          {
818            final int colonPos = s.indexOf(':');
819            final int pctPos = s.indexOf('%', colonPos);
820            final double percent =
821                 Double.parseDouble(s.substring(colonPos+1, pctPos));
822    
823            final int msPos = s.indexOf("ms");
824            if (s.startsWith("Less than "))
825            {
826              map.put(lastUpperBound, percent);
827              lastUpperBound = Long.parseLong(s.substring(10, msPos));
828            }
829            else if (s.startsWith("Between "))
830            {
831              final long lowerBound = Long.parseLong(s.substring(8, msPos));
832              map.put(lowerBound, percent);
833    
834              final int secondMSPos =  s.indexOf("ms:", msPos+1);
835              lastUpperBound = Long.parseLong(s.substring(msPos+7, secondMSPos));
836            }
837            else
838            {
839              atLeastFound = true;
840              final long lowerBound = Long.parseLong(s.substring(9, msPos));
841              map.put(lowerBound, percent);
842            }
843          }
844    
845          if (! atLeastFound)
846          {
847            map.put(lastUpperBound, 100.0d);
848          }
849    
850          return Collections.unmodifiableMap(map);
851        }
852        catch (Exception e)
853        {
854          debugException(e);
855          return Collections.emptyMap();
856        }
857      }
858    
859    
860    
861      /**
862       * Retrieves the total number of operations that have been performed in the
863       * server.
864       *
865       * @return  The total number of operations that have been performed in the
866       *          server, or {@code null} if it was not included in the monitor
867       *          entry.
868       */
869      public final Long getAllOpsTotalCount()
870      {
871        return allOpsTotalCount;
872      }
873    
874    
875    
876      /**
877       * Retrieves the average response time in milliseconds of all operations
878       * of all types performed in the server.
879       *
880       * @return  The average response time in milliseconds of all operations of all
881       *          types performed in the server, or {@code null} if it was not
882       *          included in the monitor entry.
883       */
884      public final Double getAllOpsAverageResponseTimeMillis()
885      {
886        return allOpsAvgResponseTimeMillis;
887      }
888    
889    
890    
891      /**
892       * Retrieves a map with information about the total number of operations of
893       * all types within each of the response time buckets.  The mapping will be
894       * between the lower bound for the processing time bucket in milliseconds and
895       * the number of operations whose processing time fell within that bucket.
896       *
897       * @return  A map with information about the total number of operations of all
898       *          types within each of the response time buckets, or an empty map if
899       *          it was not included in the monitor entry.
900       */
901      public final Map<Long,Long> getAllOpsCount()
902      {
903        return allOpsCount;
904      }
905    
906    
907    
908      /**
909       * Retrieves a map with information about the percentage of operations of
910       * all types within each of the response time buckets.  The mapping will be
911       * between the lower bound for the processing time bucket in milliseconds and
912       * the percentage of operations whose processing time fell within that bucket.
913       *
914       * @return  A map with information about the percentage of operations of all
915       *          types within each of the response time buckets, or an empty map if
916       *          it was not included in the monitor entry.
917       */
918      public final Map<Long,Double> getAllOpsPercent()
919      {
920        return allOpsPercent;
921      }
922    
923    
924    
925      /**
926       * Retrieves a map with information about the aggregate percentage of
927       * operations of all types within each of the response time buckets or one of
928       * the lower response time buckets.  The mapping will be between the lower
929       * bound for the processing time bucket in milliseconds and the aggregate
930       * percentage of operations whose processing time fell within that or lower
931       * response time buckets.
932       *
933       * @return  A map with information about the aggregate percentage of
934       *          operations of all types within each of the response time buckets,
935       *          or an empty map if it was not included in the monitor entry.
936       */
937      public final Map<Long,Double> getAllOpsAggregatePercent()
938      {
939        return allOpsAggregatePercent;
940      }
941    
942    
943    
944      /**
945       * Retrieves the total number of add operations that have been performed
946       * in the server.
947       *
948       * @return  The total number of add operations that have been performed in the
949       *          server, or {@code null} if it was not included in the monitor
950       *          entry.
951       */
952      public final Long getAddOpsTotalCount()
953      {
954        return addOpsTotalCount;
955      }
956    
957    
958    
959      /**
960       * Retrieves the average response time in milliseconds of add operations
961       * performed in the server.
962       *
963       * @return  The average response time in milliseconds of add operations
964       *          that have been performed in the server, or {@code null} if it was
965       *          not included in the monitor entry.
966       */
967      public final Double getAddOpsAverageResponseTimeMillis()
968      {
969        return addOpsAvgResponseTimeMillis;
970      }
971    
972    
973    
974      /**
975       * Retrieves a map with information about the total number of add operations
976       * within each of the response time buckets.  The mapping will be between
977       * the lower bound for the processing time bucket in milliseconds and the
978       * number of operations whose processing time fell within that bucket.
979       *
980       * @return  A map with information about the total number of add operations
981       *          within each of the response time buckets, or an empty map if it
982       *          was not included in the monitor entry.
983       */
984      public final Map<Long,Long> getAddOpsCount()
985      {
986        return addOpsCount;
987      }
988    
989    
990    
991      /**
992       * Retrieves a map with information about the percentage of add operations
993       * within each of the response time buckets.  The mapping will be between the
994       * lower bound for the processing time bucket in milliseconds and the
995       * percentage of operations whose processing time fell within that bucket.
996       *
997       * @return  A map with information about the percentage of add operations
998       *          within each of the response time buckets, or an empty map if it
999       *          was not included in the monitor entry.
1000       */
1001      public final Map<Long,Double> getAddOpsPercent()
1002      {
1003        return addOpsPercent;
1004      }
1005    
1006    
1007    
1008      /**
1009       * Retrieves a map with information about the aggregate percentage of add
1010       * operations within each of the response time buckets or one of the lower
1011       * response time buckets.  The mapping will be between the lower bound for the
1012       * processing time bucket in milliseconds and the aggregate percentage of
1013       * operations whose processing time fell within that or lower response time
1014       * buckets.
1015       *
1016       * @return  A map with information about the aggregate percentage of add
1017       *          operations within each of the response time buckets, or an empty
1018       *          map if it was not included in the monitor entry.
1019       */
1020      public final Map<Long,Double> getAddOpsAggregatePercent()
1021      {
1022        return addOpsAggregatePercent;
1023      }
1024    
1025    
1026    
1027      /**
1028       * Retrieves the total number of bind operations that have been performed
1029       * in the server.
1030       *
1031       * @return  The total number of bind operations that have been performed in
1032       *          the server, or {@code null} if it was not included in the monitor
1033       *          entry.
1034       */
1035      public final Long getBindOpsTotalCount()
1036      {
1037        return bindOpsTotalCount;
1038      }
1039    
1040    
1041    
1042      /**
1043       * Retrieves the average response time in milliseconds of bind operations
1044       * performed in the server.
1045       *
1046       * @return  The average response time in milliseconds of bind operations
1047       *          that have been performed in the server, or {@code null} if it was
1048       *          not included in the monitor entry.
1049       */
1050      public final Double getBindOpsAverageResponseTimeMillis()
1051      {
1052        return bindOpsAvgResponseTimeMillis;
1053      }
1054    
1055    
1056    
1057      /**
1058       * Retrieves a map with information about the total number of bind operations
1059       * within each of the response time buckets.  The mapping will be between
1060       * the lower bound for the processing time bucket in milliseconds and the
1061       * number of operations whose processing time fell within that bucket.
1062       *
1063       * @return  A map with information about the total number of bind operations
1064       *          within each of the response time buckets, or an empty map if it
1065       *          was not included in the monitor entry.
1066       */
1067      public final Map<Long,Long> getBindOpsCount()
1068      {
1069        return bindOpsCount;
1070      }
1071    
1072    
1073    
1074      /**
1075       * Retrieves a map with information about the percentage of bind operations
1076       * within each of the response time buckets.  The mapping will be between the
1077       * lower bound for the processing time bucket in milliseconds and the
1078       * percentage of operations whose processing time fell within that bucket.
1079       *
1080       * @return  A map with information about the percentage of bind operations
1081       *          within each of the response time buckets, or an empty map if it
1082       *          was not included in the monitor entry.
1083       */
1084      public final Map<Long,Double> getBindOpsPercent()
1085      {
1086        return bindOpsPercent;
1087      }
1088    
1089    
1090    
1091      /**
1092       * Retrieves a map with information about the aggregate percentage of bind
1093       * operations within each of the response time buckets or one of the lower
1094       * response time buckets.  The mapping will be between the lower bound for the
1095       * processing time bucket in milliseconds and the aggregate percentage of
1096       * operations whose processing time fell within that or lower response time
1097       * buckets.
1098       *
1099       * @return  A map with information about the aggregate percentage of bind
1100       *          operations within each of the response time buckets, or an empty
1101       *          map if it was not included in the monitor entry.
1102       */
1103      public final Map<Long,Double> getBindOpsAggregatePercent()
1104      {
1105        return bindOpsAggregatePercent;
1106      }
1107    
1108    
1109    
1110      /**
1111       * Retrieves the total number of compare operations that have been performed
1112       * in the server.
1113       *
1114       * @return  The total number of compare operations that have been performed in
1115       *          the server, or {@code null} if it was not included in the monitor
1116       *          entry.
1117       */
1118      public final Long getCompareOpsTotalCount()
1119      {
1120        return compareOpsTotalCount;
1121      }
1122    
1123    
1124    
1125      /**
1126       * Retrieves the average response time in milliseconds of compare operations
1127       * performed in the server.
1128       *
1129       * @return  The average response time in milliseconds of compare operations
1130       *          that have been performed in the server, or {@code null} if it was
1131       *          not included in the monitor entry.
1132       */
1133      public final Double getCompareOpsAverageResponseTimeMillis()
1134      {
1135        return compareOpsAvgResponseTimeMillis;
1136      }
1137    
1138    
1139    
1140      /**
1141       * Retrieves a map with information about the total number of compare
1142       * operations within each of the response time buckets.  The mapping will
1143       * be between the lower bound for the processing time bucket in milliseconds
1144       * and the number of operations whose processing time fell within that bucket.
1145       *
1146       * @return  A map with information about the total number of compare
1147       *          operations within each of the response time buckets, or an empty
1148       *          map if it was not included in the monitor entry.
1149       */
1150      public final Map<Long,Long> getCompareOpsCount()
1151      {
1152        return compareOpsCount;
1153      }
1154    
1155    
1156    
1157      /**
1158       * Retrieves a map with information about the percentage of compare operations
1159       * within each of the response time buckets.  The mapping will be between the
1160       * lower bound for the processing time bucket in milliseconds and the
1161       * percentage of operations whose processing time fell within that bucket.
1162       *
1163       * @return  A map with information about the percentage of compare operations
1164       *          within each of the response time buckets, or an empty map if it
1165       *          was not included in the monitor entry.
1166       */
1167      public final Map<Long,Double> getCompareOpsPercent()
1168      {
1169        return compareOpsPercent;
1170      }
1171    
1172    
1173    
1174      /**
1175       * Retrieves a map with information about the aggregate percentage of compare
1176       * operations within each of the response time buckets or one of the lower
1177       * response time buckets.  The mapping will be between the lower bound for the
1178       * processing time bucket in milliseconds and the aggregate percentage of
1179       * operations whose processing time fell within that or lower response time
1180       * buckets.
1181       *
1182       * @return  A map with information about the aggregate percentage of compare
1183       *          operations within each of the response time buckets, or an empty
1184       *          map if it was not included in the monitor entry.
1185       */
1186      public final Map<Long,Double> getCompareOpsAggregatePercent()
1187      {
1188        return compareOpsAggregatePercent;
1189      }
1190    
1191    
1192    
1193      /**
1194       * Retrieves the total number of delete operations that have been performed
1195       * in the server.
1196       *
1197       * @return  The total number of delete operations that have been performed in
1198       *          the server, or {@code null} if it was not included in the monitor
1199       *          entry.
1200       */
1201      public final Long getDeleteOpsTotalCount()
1202      {
1203        return deleteOpsTotalCount;
1204      }
1205    
1206    
1207    
1208      /**
1209       * Retrieves the average response time in milliseconds of delete operations
1210       * performed in the server.
1211       *
1212       * @return  The average response time in milliseconds of delete operations
1213       *          that have been performed in the server, or {@code null} if it was
1214       *          not included in the monitor entry.
1215       */
1216      public final Double getDeleteOpsAverageResponseTimeMillis()
1217      {
1218        return deleteOpsAvgResponseTimeMillis;
1219      }
1220    
1221    
1222    
1223      /**
1224       * Retrieves a map with information about the total number of delete
1225       * operations within each of the response time buckets.  The mapping will
1226       * be between the lower bound for the processing time bucket in milliseconds
1227       * and the number of operations whose processing time fell within that bucket.
1228       *
1229       * @return  A map with information about the total number of delete
1230       *          operations within each of the response time buckets, or an empty
1231       *          map if it was not included in the monitor entry.
1232       */
1233      public final Map<Long,Long> getDeleteOpsCount()
1234      {
1235        return deleteOpsCount;
1236      }
1237    
1238    
1239    
1240      /**
1241       * Retrieves a map with information about the percentage of delete operations
1242       * within each of the response time buckets.  The mapping will be between the
1243       * lower bound for the processing time bucket in milliseconds and the
1244       * percentage of operations whose processing time fell within that bucket.
1245       *
1246       * @return  A map with information about the percentage of delete operations
1247       *          within each of the response time buckets, or an empty map if it
1248       *          was not included in the monitor entry.
1249       */
1250      public final Map<Long,Double> getDeleteOpsPercent()
1251      {
1252        return deleteOpsPercent;
1253      }
1254    
1255    
1256    
1257      /**
1258       * Retrieves a map with information about the aggregate percentage of delete
1259       * operations within each of the response time buckets or one of the lower
1260       * response time buckets.  The mapping will be between the lower bound for the
1261       * processing time bucket in milliseconds and the aggregate percentage of
1262       * operations whose processing time fell within that or lower response time
1263       * buckets.
1264       *
1265       * @return  A map with information about the aggregate percentage of delete
1266       *          operations within each of the response time buckets, or an empty
1267       *          map if it was not included in the monitor entry.
1268       */
1269      public final Map<Long,Double> getDeleteOpsAggregatePercent()
1270      {
1271        return deleteOpsAggregatePercent;
1272      }
1273    
1274    
1275    
1276      /**
1277       * Retrieves the total number of extended operations that have been performed
1278       * in the server.
1279       *
1280       * @return  The total number of extended operations that have been performed
1281       *          in the server, or {@code null} if it was not included in the
1282       *          monitor entry.
1283       */
1284      public final Long getExtendedOpsTotalCount()
1285      {
1286        return extendedOpsTotalCount;
1287      }
1288    
1289    
1290    
1291      /**
1292       * Retrieves the average response time in milliseconds of extended operations
1293       * performed in the server.
1294       *
1295       * @return  The average response time in milliseconds of extended operations
1296       *          that have been performed in the server, or {@code null} if it was
1297       *          not included in the monitor entry.
1298       */
1299      public final Double getExtendedOpsAverageResponseTimeMillis()
1300      {
1301        return extendedOpsAvgResponseTimeMillis;
1302      }
1303    
1304    
1305    
1306      /**
1307       * Retrieves a map with information about the total number of extended
1308       * operations within each of the response time buckets.  The mapping will be
1309       * between the lower bound for the processing time bucket in milliseconds and
1310       * the number of operations whose processing time fell within that bucket.
1311       *
1312       * @return  A map with information about the total number of extended
1313       *          operations within each of the response time buckets, or an empty
1314       *          map if it was not included in the monitor entry.
1315       */
1316      public final Map<Long,Long> getExtendedOpsCount()
1317      {
1318        return extendedOpsCount;
1319      }
1320    
1321    
1322    
1323      /**
1324       * Retrieves a map with information about the percentage of extended
1325       * operations within each of the response time buckets.  The mapping will be
1326       * between the lower bound for the processing time bucket in milliseconds and
1327       * the percentage of operations whose processing time fell within that bucket.
1328       *
1329       * @return  A map with information about the percentage of extended operations
1330       *          within each of the response time buckets, or an empty map if it
1331       *          was not included in the monitor entry.
1332       */
1333      public final Map<Long,Double> getExtendedOpsPercent()
1334      {
1335        return extendedOpsPercent;
1336      }
1337    
1338    
1339    
1340      /**
1341       * Retrieves a map with information about the aggregate percentage of extended
1342       * operations within each of the response time buckets or one of the lower
1343       * response time buckets.  The mapping will be between the lower bound for the
1344       * processing time bucket in milliseconds and the aggregate percentage of
1345       * operations whose processing time fell within that or lower response time
1346       * buckets.
1347       *
1348       * @return  A map with information about the aggregate percentage of extended
1349       *          operations within each of the response time buckets, or an empty
1350       *          map if it was not included in the monitor entry.
1351       */
1352      public final Map<Long,Double> getExtendedOpsAggregatePercent()
1353      {
1354        return extendedOpsAggregatePercent;
1355      }
1356    
1357    
1358    
1359      /**
1360       * Retrieves the total number of modify operations that have been performed
1361       * in the server.
1362       *
1363       * @return  The total number of modify operations that have been performed in
1364       *          the server, or {@code null} if it was not included in the monitor
1365       *          entry.
1366       */
1367      public final Long getModifyOpsTotalCount()
1368      {
1369        return modifyOpsTotalCount;
1370      }
1371    
1372    
1373    
1374      /**
1375       * Retrieves the average response time in milliseconds of modify operations
1376       * performed in the server.
1377       *
1378       * @return  The average response time in milliseconds of modify operations
1379       *          that have been performed in the server, or {@code null} if it was
1380       *          not included in the monitor entry.
1381       */
1382      public final Double getModifyOpsAverageResponseTimeMillis()
1383      {
1384        return modifyOpsAvgResponseTimeMillis;
1385      }
1386    
1387    
1388    
1389      /**
1390       * Retrieves a map with information about the total number of modify
1391       * operations within each of the response time buckets.  The mapping will
1392       * be between the lower bound for the processing time bucket in milliseconds
1393       * and the number of operations whose processing time fell within that bucket.
1394       *
1395       * @return  A map with information about the total number of modify
1396       *          operations within each of the response time buckets, or an empty
1397       *          map if it was not included in the monitor entry.
1398       */
1399      public final Map<Long,Long> getModifyOpsCount()
1400      {
1401        return modifyOpsCount;
1402      }
1403    
1404    
1405    
1406      /**
1407       * Retrieves a map with information about the percentage of modify operations
1408       * within each of the response time buckets.  The mapping will be between the
1409       * lower bound for the processing time bucket in milliseconds and the
1410       * percentage of operations whose processing time fell within that bucket.
1411       *
1412       * @return  A map with information about the percentage of modify operations
1413       *          within each of the response time buckets, or an empty map if it
1414       *          was not included in the monitor entry.
1415       */
1416      public final Map<Long,Double> getModifyOpsPercent()
1417      {
1418        return modifyOpsPercent;
1419      }
1420    
1421    
1422    
1423      /**
1424       * Retrieves a map with information about the aggregate percentage of modify
1425       * operations within each of the response time buckets or one of the lower
1426       * response time buckets.  The mapping will be between the lower bound for the
1427       * processing time bucket in milliseconds and the aggregate percentage of
1428       * operations whose processing time fell within that or lower response time
1429       * buckets.
1430       *
1431       * @return  A map with information about the aggregate percentage of modify
1432       *          operations within each of the response time buckets, or an empty
1433       *          map if it was not included in the monitor entry.
1434       */
1435      public final Map<Long,Double> getModifyOpsAggregatePercent()
1436      {
1437        return modifyOpsAggregatePercent;
1438      }
1439    
1440    
1441    
1442      /**
1443       * Retrieves a map with information about the total number of modify DN
1444       * operations within each of the response time buckets.  The mapping will
1445       * be between the lower bound for the processing time bucket in milliseconds
1446       * and the number of operations whose processing time fell within that bucket.
1447       *
1448       * @return  A map with information about the total number of modify DN
1449       *          operations within each of the response time buckets, or an empty
1450       *          map if it was not included in the monitor entry.
1451       */
1452      public final Map<Long,Long> getModifyDNOpsCount()
1453      {
1454        return modifyDNOpsCount;
1455      }
1456    
1457    
1458    
1459      /**
1460       * Retrieves the total number of modify DN operations that have been performed
1461       * in the server.
1462       *
1463       * @return  The total number of modify DN operations that have been performed
1464       *          in the server, or {@code null} if it was not included in the
1465       *          monitor entry.
1466       */
1467      public final Long getModifyDNOpsTotalCount()
1468      {
1469        return modifyDNOpsTotalCount;
1470      }
1471    
1472    
1473    
1474      /**
1475       * Retrieves the average response time in milliseconds of modify DN operations
1476       * performed in the server.
1477       *
1478       * @return  The average response time in milliseconds of modify DN operations
1479       *          that have been performed in the server, or {@code null} if it was
1480       *          not included in the monitor entry.
1481       */
1482      public final Double getModifyDNOpsAverageResponseTimeMillis()
1483      {
1484        return modifyDNOpsAvgResponseTimeMillis;
1485      }
1486    
1487    
1488    
1489      /**
1490       * Retrieves a map with information about the percentage of modify DN
1491       * operations within each of the response time buckets.  The mapping will be
1492       * between the lower bound for the processing time bucket in milliseconds and
1493       * the percentage of operations whose processing time fell within that bucket.
1494       *
1495       * @return  A map with information about the percentage of modify DN
1496       *          operations within each of the response time buckets, or an empty
1497       *          map if it was not included in the monitor entry.
1498       */
1499      public final Map<Long,Double> getModifyDNOpsPercent()
1500      {
1501        return modifyDNOpsPercent;
1502      }
1503    
1504    
1505    
1506      /**
1507       * Retrieves a map with information about the aggregate percentage of modify
1508       * DN operations within each of the response time buckets or one of the lower
1509       * response time buckets.  The mapping will be between the lower bound for the
1510       * processing time bucket in milliseconds and the aggregate percentage of
1511       * operations whose processing time fell within that or lower response time
1512       * buckets.
1513       *
1514       * @return  A map with information about the aggregate percentage of modify DN
1515       *          operations within each of the response time buckets, or an empty
1516       *          map if it was not included in the monitor entry.
1517       */
1518      public final Map<Long,Double> getModifyDNOpsAggregatePercent()
1519      {
1520        return modifyDNOpsAggregatePercent;
1521      }
1522    
1523    
1524    
1525      /**
1526       * Retrieves the total number of search operations that have been performed
1527       * in the server.
1528       *
1529       * @return  The total number of search operations that have been performed in
1530       *          the server, or {@code null} if it was not included in the monitor
1531       *          entry.
1532       */
1533      public final Long getSearchOpsTotalCount()
1534      {
1535        return searchOpsTotalCount;
1536      }
1537    
1538    
1539    
1540      /**
1541       * Retrieves the average response time in milliseconds of search operations
1542       * performed in the server.
1543       *
1544       * @return  The average response time in milliseconds of search operations
1545       *          that have been performed in the server, or {@code null} if it was
1546       *          not included in the monitor entry.
1547       */
1548      public final Double getSearchOpsAverageResponseTimeMillis()
1549      {
1550        return searchOpsAvgResponseTimeMillis;
1551      }
1552    
1553    
1554    
1555      /**
1556       * Retrieves a map with information about the total number of search
1557       * operations within each of the response time buckets.  The mapping will
1558       * be between the lower bound for the processing time bucket in milliseconds
1559       * and the number of operations whose processing time fell within that bucket.
1560       *
1561       * @return  A map with information about the total number of search
1562       *          operations within each of the response time buckets, or an empty
1563       *          map if it was not included in the monitor entry.
1564       */
1565      public final Map<Long,Long> getSearchOpsCount()
1566      {
1567        return searchOpsCount;
1568      }
1569    
1570    
1571    
1572      /**
1573       * Retrieves a map with information about the percentage of search operations
1574       * within each of the response time buckets.  The mapping will be between the
1575       * lower bound for the processing time bucket in milliseconds and the
1576       * percentage of operations whose processing time fell within that bucket.
1577       *
1578       * @return  A map with information about the percentage of search operations
1579       *          within each of the response time buckets, or an empty map if it
1580       *          was not included in the monitor entry.
1581       */
1582      public final Map<Long,Double> getSearchOpsPercent()
1583      {
1584        return searchOpsPercent;
1585      }
1586    
1587    
1588    
1589      /**
1590       * Retrieves a map with information about the aggregate percentage of search
1591       * operations within each of the response time buckets or one of the lower
1592       * response time buckets.  The mapping will be between the lower bound for the
1593       * processing time bucket in milliseconds and the aggregate percentage of
1594       * operations whose processing time fell within that or lower response time
1595       * buckets.
1596       *
1597       * @return  A map with information about the aggregate percentage of search
1598       *          operations within each of the response time buckets, or an empty
1599       *          map if it was not included in the monitor entry.
1600       */
1601      public final Map<Long,Double> getSearchOpsAggregatePercent()
1602      {
1603        return searchOpsAggregatePercent;
1604      }
1605    
1606    
1607    
1608      /**
1609       * {@inheritDoc}
1610       */
1611      @Override()
1612      public String getMonitorDisplayName()
1613      {
1614        return INFO_PROCESSING_TIME_MONITOR_DISPNAME.get();
1615      }
1616    
1617    
1618    
1619      /**
1620       * {@inheritDoc}
1621       */
1622      @Override()
1623      public String getMonitorDescription()
1624      {
1625        return INFO_PROCESSING_TIME_MONITOR_DESC.get();
1626      }
1627    
1628    
1629    
1630      /**
1631       * {@inheritDoc}
1632       */
1633      @Override()
1634      public Map<String,MonitorAttribute> getMonitorAttributes()
1635      {
1636        final LinkedHashMap<String,MonitorAttribute> attrs =
1637             new LinkedHashMap<String,MonitorAttribute>();
1638    
1639        if (allOpsTotalCount != null)
1640        {
1641          addMonitorAttribute(attrs,
1642               ATTR_ALL_TOTAL_COUNT,
1643               INFO_PROCESSING_TIME_DISPNAME_ALL_TOTAL_COUNT.get(),
1644               INFO_PROCESSING_TIME_DESC_ALL_TOTAL_COUNT.get(),
1645               allOpsTotalCount);
1646        }
1647    
1648        if (allOpsAvgResponseTimeMillis != null)
1649        {
1650          addMonitorAttribute(attrs,
1651               ATTR_ALL_AVERAGE_RESPONSE_TIME_MS,
1652               INFO_PROCESSING_TIME_DISPNAME_ALL_TOTAL_TIME.get(),
1653               INFO_PROCESSING_TIME_DESC_ALL_TOTAL_TIME.get(),
1654               allOpsAvgResponseTimeMillis);
1655        }
1656    
1657        if (! allOpsCount.isEmpty())
1658        {
1659          final Iterator<Long> iterator = allOpsCount.keySet().iterator();
1660          Long lastValue = iterator.next();
1661    
1662          while (iterator.hasNext())
1663          {
1664            final Long value = iterator.next();
1665            addMonitorAttribute(attrs,
1666                 "allOpsCount-" + lastValue + '-' + value,
1667                 INFO_PROCESSING_TIME_DISPNAME_ALL_COUNT.get(lastValue, value),
1668                 INFO_PROCESSING_TIME_DESC_ALL_COUNT.get(lastValue, value),
1669                 allOpsCount.get(lastValue));
1670    
1671            lastValue = value;
1672            if (! iterator.hasNext())
1673            {
1674              addMonitorAttribute(attrs,
1675                   "allOpsCount-" + lastValue,
1676                   INFO_PROCESSING_TIME_DISPNAME_ALL_COUNT_LAST.get(lastValue),
1677                   INFO_PROCESSING_TIME_DESC_ALL_COUNT_LAST.get(lastValue),
1678                   allOpsCount.get(lastValue));
1679            }
1680          }
1681        }
1682    
1683        if (! allOpsPercent.isEmpty())
1684        {
1685          final Iterator<Long> iterator = allOpsPercent.keySet().iterator();
1686          Long lastValue = iterator.next();
1687    
1688          while (iterator.hasNext())
1689          {
1690            final Long value = iterator.next();
1691            addMonitorAttribute(attrs,
1692                 "allOpsPct-" + lastValue + '-' + value,
1693                 INFO_PROCESSING_TIME_DISPNAME_ALL_PCT.get(lastValue, value),
1694                 INFO_PROCESSING_TIME_DESC_ALL_PCT.get(lastValue, value),
1695                 allOpsPercent.get(lastValue));
1696    
1697            lastValue = value;
1698            if (! iterator.hasNext())
1699            {
1700              addMonitorAttribute(attrs,
1701                   "allOpsPct-" + lastValue,
1702                   INFO_PROCESSING_TIME_DISPNAME_ALL_PCT_LAST.get(lastValue),
1703                   INFO_PROCESSING_TIME_DESC_ALL_PCT_LAST.get(lastValue),
1704                   allOpsPercent.get(lastValue));
1705            }
1706          }
1707        }
1708    
1709        if (! allOpsAggregatePercent.isEmpty())
1710        {
1711          final Iterator<Long> iterator =
1712               allOpsAggregatePercent.keySet().iterator();
1713          Long lastValue = iterator.next();
1714    
1715          while (iterator.hasNext())
1716          {
1717            final Long value = iterator.next();
1718            addMonitorAttribute(attrs,
1719                 "allOpsAggrPct-" + lastValue + '-' + value,
1720                 INFO_PROCESSING_TIME_DISPNAME_ALL_AGGR_PCT.get(lastValue, value),
1721                 INFO_PROCESSING_TIME_DESC_ALL_AGGR_PCT.get(lastValue, value),
1722                 allOpsAggregatePercent.get(lastValue));
1723    
1724            lastValue = value;
1725          }
1726        }
1727    
1728        if (addOpsTotalCount != null)
1729        {
1730          addMonitorAttribute(attrs,
1731               ATTR_ADD_TOTAL_COUNT,
1732               INFO_PROCESSING_TIME_DISPNAME_ADD_TOTAL_COUNT.get(),
1733               INFO_PROCESSING_TIME_DESC_ADD_TOTAL_COUNT.get(),
1734               addOpsTotalCount);
1735        }
1736    
1737        if (addOpsAvgResponseTimeMillis != null)
1738        {
1739          addMonitorAttribute(attrs,
1740               ATTR_ADD_AVERAGE_RESPONSE_TIME_MS,
1741               INFO_PROCESSING_TIME_DISPNAME_ADD_TOTAL_TIME.get(),
1742               INFO_PROCESSING_TIME_DESC_ADD_TOTAL_TIME.get(),
1743               addOpsAvgResponseTimeMillis);
1744        }
1745    
1746        if (! addOpsCount.isEmpty())
1747        {
1748          final Iterator<Long> iterator = addOpsCount.keySet().iterator();
1749          Long lastValue = iterator.next();
1750    
1751          while (iterator.hasNext())
1752          {
1753            final Long value = iterator.next();
1754            addMonitorAttribute(attrs,
1755                 "addOpsCount-" + lastValue + '-' + value,
1756                 INFO_PROCESSING_TIME_DISPNAME_ADD_COUNT.get(lastValue, value),
1757                 INFO_PROCESSING_TIME_DESC_ADD_COUNT.get(lastValue, value),
1758                 addOpsCount.get(lastValue));
1759    
1760            lastValue = value;
1761            if (! iterator.hasNext())
1762            {
1763              addMonitorAttribute(attrs,
1764                   "addOpsCount-" + lastValue,
1765                   INFO_PROCESSING_TIME_DISPNAME_ADD_COUNT_LAST.get(lastValue),
1766                   INFO_PROCESSING_TIME_DESC_ADD_COUNT_LAST.get(lastValue),
1767                   addOpsCount.get(lastValue));
1768            }
1769          }
1770        }
1771    
1772        if (! addOpsPercent.isEmpty())
1773        {
1774          final Iterator<Long> iterator = addOpsPercent.keySet().iterator();
1775          Long lastValue = iterator.next();
1776    
1777          while (iterator.hasNext())
1778          {
1779            final Long value = iterator.next();
1780            addMonitorAttribute(attrs,
1781                 "addOpsPct-" + lastValue + '-' + value,
1782                 INFO_PROCESSING_TIME_DISPNAME_ADD_PCT.get(lastValue, value),
1783                 INFO_PROCESSING_TIME_DESC_ADD_PCT.get(lastValue, value),
1784                 addOpsPercent.get(lastValue));
1785    
1786            lastValue = value;
1787            if (! iterator.hasNext())
1788            {
1789              addMonitorAttribute(attrs,
1790                   "addOpsPct-" + lastValue,
1791                   INFO_PROCESSING_TIME_DISPNAME_ADD_PCT_LAST.get(lastValue),
1792                   INFO_PROCESSING_TIME_DESC_ADD_PCT_LAST.get(lastValue),
1793                   addOpsPercent.get(lastValue));
1794            }
1795          }
1796        }
1797    
1798        if (! addOpsAggregatePercent.isEmpty())
1799        {
1800          final Iterator<Long> iterator =
1801               addOpsAggregatePercent.keySet().iterator();
1802          Long lastValue = iterator.next();
1803    
1804          while (iterator.hasNext())
1805          {
1806            final Long value = iterator.next();
1807            addMonitorAttribute(attrs,
1808                 "addOpsAggrPct-" + lastValue + '-' + value,
1809                 INFO_PROCESSING_TIME_DISPNAME_ADD_AGGR_PCT.get(lastValue, value),
1810                 INFO_PROCESSING_TIME_DESC_ADD_AGGR_PCT.get(lastValue, value),
1811                 addOpsAggregatePercent.get(lastValue));
1812    
1813            lastValue = value;
1814          }
1815        }
1816    
1817        if (bindOpsTotalCount != null)
1818        {
1819          addMonitorAttribute(attrs,
1820               ATTR_BIND_TOTAL_COUNT,
1821               INFO_PROCESSING_TIME_DISPNAME_BIND_TOTAL_COUNT.get(),
1822               INFO_PROCESSING_TIME_DESC_BIND_TOTAL_COUNT.get(),
1823               bindOpsTotalCount);
1824        }
1825    
1826        if (bindOpsAvgResponseTimeMillis != null)
1827        {
1828          addMonitorAttribute(attrs,
1829               ATTR_BIND_AVERAGE_RESPONSE_TIME_MS,
1830               INFO_PROCESSING_TIME_DISPNAME_BIND_TOTAL_TIME.get(),
1831               INFO_PROCESSING_TIME_DESC_BIND_TOTAL_TIME.get(),
1832               bindOpsAvgResponseTimeMillis);
1833        }
1834    
1835        if (! bindOpsCount.isEmpty())
1836        {
1837          final Iterator<Long> iterator = bindOpsCount.keySet().iterator();
1838          Long lastValue = iterator.next();
1839    
1840          while (iterator.hasNext())
1841          {
1842            final Long value = iterator.next();
1843            addMonitorAttribute(attrs,
1844                 "bindOpsCount-" + lastValue + '-' + value,
1845                 INFO_PROCESSING_TIME_DISPNAME_BIND_COUNT.get(lastValue, value),
1846                 INFO_PROCESSING_TIME_DESC_BIND_COUNT.get(lastValue, value),
1847                 bindOpsCount.get(lastValue));
1848    
1849            lastValue = value;
1850            if (! iterator.hasNext())
1851            {
1852              addMonitorAttribute(attrs,
1853                   "bindOpsCount-" + lastValue,
1854                   INFO_PROCESSING_TIME_DISPNAME_BIND_COUNT_LAST.get(lastValue),
1855                   INFO_PROCESSING_TIME_DESC_BIND_COUNT_LAST.get(lastValue),
1856                   bindOpsCount.get(lastValue));
1857            }
1858          }
1859        }
1860    
1861        if (! bindOpsPercent.isEmpty())
1862        {
1863          final Iterator<Long> iterator = bindOpsPercent.keySet().iterator();
1864          Long lastValue = iterator.next();
1865    
1866          while (iterator.hasNext())
1867          {
1868            final Long value = iterator.next();
1869            addMonitorAttribute(attrs,
1870                 "bindOpsPct-" + lastValue + '-' + value,
1871                 INFO_PROCESSING_TIME_DISPNAME_BIND_PCT.get(lastValue, value),
1872                 INFO_PROCESSING_TIME_DESC_BIND_PCT.get(lastValue, value),
1873                 bindOpsPercent.get(lastValue));
1874    
1875            lastValue = value;
1876            if (! iterator.hasNext())
1877            {
1878              addMonitorAttribute(attrs,
1879                   "bindOpsPct-" + lastValue,
1880                   INFO_PROCESSING_TIME_DISPNAME_BIND_PCT_LAST.get(lastValue),
1881                   INFO_PROCESSING_TIME_DESC_BIND_PCT_LAST.get(lastValue),
1882                   bindOpsPercent.get(lastValue));
1883            }
1884          }
1885        }
1886    
1887        if (! bindOpsAggregatePercent.isEmpty())
1888        {
1889          final Iterator<Long> iterator =
1890               bindOpsAggregatePercent.keySet().iterator();
1891          Long lastValue = iterator.next();
1892    
1893          while (iterator.hasNext())
1894          {
1895            final Long value = iterator.next();
1896            addMonitorAttribute(attrs,
1897                 "bindOpsAggrPct-" + lastValue + '-' + value,
1898                 INFO_PROCESSING_TIME_DISPNAME_BIND_AGGR_PCT.get(lastValue, value),
1899                 INFO_PROCESSING_TIME_DESC_BIND_AGGR_PCT.get(lastValue, value),
1900                 bindOpsAggregatePercent.get(lastValue));
1901    
1902            lastValue = value;
1903          }
1904        }
1905    
1906        if (compareOpsTotalCount != null)
1907        {
1908          addMonitorAttribute(attrs,
1909               ATTR_COMPARE_TOTAL_COUNT,
1910               INFO_PROCESSING_TIME_DISPNAME_COMPARE_TOTAL_COUNT.get(),
1911               INFO_PROCESSING_TIME_DESC_COMPARE_TOTAL_COUNT.get(),
1912               compareOpsTotalCount);
1913        }
1914    
1915        if (compareOpsAvgResponseTimeMillis != null)
1916        {
1917          addMonitorAttribute(attrs,
1918               ATTR_COMPARE_AVERAGE_RESPONSE_TIME_MS,
1919               INFO_PROCESSING_TIME_DISPNAME_COMPARE_TOTAL_TIME.get(),
1920               INFO_PROCESSING_TIME_DESC_COMPARE_TOTAL_TIME.get(),
1921               compareOpsAvgResponseTimeMillis);
1922        }
1923    
1924        if (! compareOpsCount.isEmpty())
1925        {
1926          final Iterator<Long> iterator = compareOpsCount.keySet().iterator();
1927          Long lastValue = iterator.next();
1928    
1929          while (iterator.hasNext())
1930          {
1931            final Long value = iterator.next();
1932            addMonitorAttribute(attrs,
1933                 "compareOpsCount-" + lastValue + '-' + value,
1934                 INFO_PROCESSING_TIME_DISPNAME_COMPARE_COUNT.get(lastValue, value),
1935                 INFO_PROCESSING_TIME_DESC_COMPARE_COUNT.get(lastValue, value),
1936                 compareOpsCount.get(lastValue));
1937    
1938            lastValue = value;
1939            if (! iterator.hasNext())
1940            {
1941              addMonitorAttribute(attrs,
1942                   "compareOpsCount-" + lastValue,
1943                   INFO_PROCESSING_TIME_DISPNAME_COMPARE_COUNT_LAST.get(lastValue),
1944                   INFO_PROCESSING_TIME_DESC_COMPARE_COUNT_LAST.get(lastValue),
1945                   compareOpsCount.get(lastValue));
1946            }
1947          }
1948        }
1949    
1950        if (! compareOpsPercent.isEmpty())
1951        {
1952          final Iterator<Long> iterator = compareOpsPercent.keySet().iterator();
1953          Long lastValue = iterator.next();
1954    
1955          while (iterator.hasNext())
1956          {
1957            final Long value = iterator.next();
1958            addMonitorAttribute(attrs,
1959                 "compareOpsPct-" + lastValue + '-' + value,
1960                 INFO_PROCESSING_TIME_DISPNAME_COMPARE_PCT.get(lastValue, value),
1961                 INFO_PROCESSING_TIME_DESC_COMPARE_PCT.get(lastValue, value),
1962                 compareOpsPercent.get(lastValue));
1963    
1964            lastValue = value;
1965            if (! iterator.hasNext())
1966            {
1967              addMonitorAttribute(attrs,
1968                   "compareOpsPct-" + lastValue,
1969                   INFO_PROCESSING_TIME_DISPNAME_COMPARE_PCT_LAST.get(lastValue),
1970                   INFO_PROCESSING_TIME_DESC_COMPARE_PCT_LAST.get(lastValue),
1971                   compareOpsPercent.get(lastValue));
1972            }
1973          }
1974        }
1975    
1976        if (! compareOpsAggregatePercent.isEmpty())
1977        {
1978          final Iterator<Long> iterator =
1979               compareOpsAggregatePercent.keySet().iterator();
1980          Long lastValue = iterator.next();
1981    
1982          while (iterator.hasNext())
1983          {
1984            final Long value = iterator.next();
1985            addMonitorAttribute(attrs,
1986                 "compareOpsAggrPct-" + lastValue + '-' + value,
1987                 INFO_PROCESSING_TIME_DISPNAME_COMPARE_AGGR_PCT.get(lastValue,
1988                                                                    value),
1989                 INFO_PROCESSING_TIME_DESC_COMPARE_AGGR_PCT.get(lastValue, value),
1990                 compareOpsAggregatePercent.get(lastValue));
1991    
1992            lastValue = value;
1993          }
1994        }
1995    
1996        if (deleteOpsTotalCount != null)
1997        {
1998          addMonitorAttribute(attrs,
1999               ATTR_DELETE_TOTAL_COUNT,
2000               INFO_PROCESSING_TIME_DISPNAME_DELETE_TOTAL_COUNT.get(),
2001               INFO_PROCESSING_TIME_DESC_DELETE_TOTAL_COUNT.get(),
2002               deleteOpsTotalCount);
2003        }
2004    
2005        if (deleteOpsAvgResponseTimeMillis != null)
2006        {
2007          addMonitorAttribute(attrs,
2008               ATTR_DELETE_AVERAGE_RESPONSE_TIME_MS,
2009               INFO_PROCESSING_TIME_DISPNAME_DELETE_TOTAL_TIME.get(),
2010               INFO_PROCESSING_TIME_DESC_DELETE_TOTAL_TIME.get(),
2011               deleteOpsAvgResponseTimeMillis);
2012        }
2013    
2014        if (! deleteOpsCount.isEmpty())
2015        {
2016          final Iterator<Long> iterator = deleteOpsCount.keySet().iterator();
2017          Long lastValue = iterator.next();
2018    
2019          while (iterator.hasNext())
2020          {
2021            final Long value = iterator.next();
2022            addMonitorAttribute(attrs,
2023                 "deleteOpsCount-" + lastValue + '-' + value,
2024                 INFO_PROCESSING_TIME_DISPNAME_DELETE_COUNT.get(lastValue, value),
2025                 INFO_PROCESSING_TIME_DESC_DELETE_COUNT.get(lastValue, value),
2026                 deleteOpsCount.get(lastValue));
2027    
2028            lastValue = value;
2029            if (! iterator.hasNext())
2030            {
2031              addMonitorAttribute(attrs,
2032                   "deleteOpsCount-" + lastValue,
2033                   INFO_PROCESSING_TIME_DISPNAME_DELETE_COUNT_LAST.get(lastValue),
2034                   INFO_PROCESSING_TIME_DESC_DELETE_COUNT_LAST.get(lastValue),
2035                   deleteOpsCount.get(lastValue));
2036            }
2037          }
2038        }
2039    
2040        if (! deleteOpsPercent.isEmpty())
2041        {
2042          final Iterator<Long> iterator = deleteOpsPercent.keySet().iterator();
2043          Long lastValue = iterator.next();
2044    
2045          while (iterator.hasNext())
2046          {
2047            final Long value = iterator.next();
2048            addMonitorAttribute(attrs,
2049                 "deleteOpsPct-" + lastValue + '-' + value,
2050                 INFO_PROCESSING_TIME_DISPNAME_DELETE_PCT.get(lastValue, value),
2051                 INFO_PROCESSING_TIME_DESC_DELETE_PCT.get(lastValue, value),
2052                 deleteOpsPercent.get(lastValue));
2053    
2054            lastValue = value;
2055            if (! iterator.hasNext())
2056            {
2057              addMonitorAttribute(attrs,
2058                   "deleteOpsPct-" + lastValue,
2059                   INFO_PROCESSING_TIME_DISPNAME_DELETE_PCT_LAST.get(lastValue),
2060                   INFO_PROCESSING_TIME_DESC_DELETE_PCT_LAST.get(lastValue),
2061                   deleteOpsPercent.get(lastValue));
2062            }
2063          }
2064        }
2065    
2066        if (! deleteOpsAggregatePercent.isEmpty())
2067        {
2068          final Iterator<Long> iterator =
2069               deleteOpsAggregatePercent.keySet().iterator();
2070          Long lastValue = iterator.next();
2071    
2072          while (iterator.hasNext())
2073          {
2074            final Long value = iterator.next();
2075            addMonitorAttribute(attrs,
2076                 "deleteOpsAggrPct-" + lastValue + '-' + value,
2077                 INFO_PROCESSING_TIME_DISPNAME_DELETE_AGGR_PCT.get(lastValue,
2078                                                                   value),
2079                 INFO_PROCESSING_TIME_DESC_DELETE_AGGR_PCT.get(lastValue, value),
2080                 deleteOpsAggregatePercent.get(lastValue));
2081    
2082            lastValue = value;
2083          }
2084        }
2085    
2086        if (extendedOpsTotalCount != null)
2087        {
2088          addMonitorAttribute(attrs,
2089               ATTR_EXTENDED_TOTAL_COUNT,
2090               INFO_PROCESSING_TIME_DISPNAME_EXTENDED_TOTAL_COUNT.get(),
2091               INFO_PROCESSING_TIME_DESC_EXTENDED_TOTAL_COUNT.get(),
2092               extendedOpsTotalCount);
2093        }
2094    
2095        if (extendedOpsAvgResponseTimeMillis != null)
2096        {
2097          addMonitorAttribute(attrs,
2098               ATTR_EXTENDED_AVERAGE_RESPONSE_TIME_MS,
2099               INFO_PROCESSING_TIME_DISPNAME_EXTENDED_TOTAL_TIME.get(),
2100               INFO_PROCESSING_TIME_DESC_EXTENDED_TOTAL_TIME.get(),
2101               extendedOpsAvgResponseTimeMillis);
2102        }
2103    
2104        if (! extendedOpsCount.isEmpty())
2105        {
2106          final Iterator<Long> iterator = extendedOpsCount.keySet().iterator();
2107          Long lastValue = iterator.next();
2108    
2109          while (iterator.hasNext())
2110          {
2111            final Long value = iterator.next();
2112            addMonitorAttribute(attrs,
2113                 "extendedOpsCount-" + lastValue + '-' + value,
2114                 INFO_PROCESSING_TIME_DISPNAME_EXTENDED_COUNT.get(lastValue, value),
2115                 INFO_PROCESSING_TIME_DESC_EXTENDED_COUNT.get(lastValue, value),
2116                 extendedOpsCount.get(lastValue));
2117    
2118            lastValue = value;
2119            if (! iterator.hasNext())
2120            {
2121              addMonitorAttribute(attrs,
2122                   "extendedOpsCount-" + lastValue,
2123                   INFO_PROCESSING_TIME_DISPNAME_EXTENDED_COUNT_LAST.get(lastValue),
2124                   INFO_PROCESSING_TIME_DESC_EXTENDED_COUNT_LAST.get(lastValue),
2125                   extendedOpsCount.get(lastValue));
2126            }
2127          }
2128        }
2129    
2130        if (! extendedOpsPercent.isEmpty())
2131        {
2132          final Iterator<Long> iterator = extendedOpsPercent.keySet().iterator();
2133          Long lastValue = iterator.next();
2134    
2135          while (iterator.hasNext())
2136          {
2137            final Long value = iterator.next();
2138            addMonitorAttribute(attrs,
2139                 "extendedOpsPct-" + lastValue + '-' + value,
2140                 INFO_PROCESSING_TIME_DISPNAME_EXTENDED_PCT.get(lastValue, value),
2141                 INFO_PROCESSING_TIME_DESC_EXTENDED_PCT.get(lastValue, value),
2142                 extendedOpsPercent.get(lastValue));
2143    
2144            lastValue = value;
2145            if (! iterator.hasNext())
2146            {
2147              addMonitorAttribute(attrs,
2148                   "extendedOpsPct-" + lastValue,
2149                   INFO_PROCESSING_TIME_DISPNAME_EXTENDED_PCT_LAST.get(lastValue),
2150                   INFO_PROCESSING_TIME_DESC_EXTENDED_PCT_LAST.get(lastValue),
2151                   extendedOpsPercent.get(lastValue));
2152            }
2153          }
2154        }
2155    
2156        if (! extendedOpsAggregatePercent.isEmpty())
2157        {
2158          final Iterator<Long> iterator =
2159               extendedOpsAggregatePercent.keySet().iterator();
2160          Long lastValue = iterator.next();
2161    
2162          while (iterator.hasNext())
2163          {
2164            final Long value = iterator.next();
2165            addMonitorAttribute(attrs,
2166                 "extendedOpsAggrPct-" + lastValue + '-' + value,
2167                 INFO_PROCESSING_TIME_DISPNAME_EXTENDED_AGGR_PCT.get(lastValue,
2168                                                                     value),
2169                 INFO_PROCESSING_TIME_DESC_EXTENDED_AGGR_PCT.get(lastValue, value),
2170                 extendedOpsAggregatePercent.get(lastValue));
2171    
2172            lastValue = value;
2173          }
2174        }
2175    
2176        if (modifyOpsTotalCount != null)
2177        {
2178          addMonitorAttribute(attrs,
2179               ATTR_MODIFY_TOTAL_COUNT,
2180               INFO_PROCESSING_TIME_DISPNAME_MODIFY_TOTAL_COUNT.get(),
2181               INFO_PROCESSING_TIME_DESC_MODIFY_TOTAL_COUNT.get(),
2182               modifyOpsTotalCount);
2183        }
2184    
2185        if (modifyOpsAvgResponseTimeMillis != null)
2186        {
2187          addMonitorAttribute(attrs,
2188               ATTR_MODIFY_AVERAGE_RESPONSE_TIME_MS,
2189               INFO_PROCESSING_TIME_DISPNAME_MODIFY_TOTAL_TIME.get(),
2190               INFO_PROCESSING_TIME_DESC_MODIFY_TOTAL_TIME.get(),
2191               modifyOpsAvgResponseTimeMillis);
2192        }
2193    
2194        if (! modifyOpsCount.isEmpty())
2195        {
2196          final Iterator<Long> iterator = modifyOpsCount.keySet().iterator();
2197          Long lastValue = iterator.next();
2198    
2199          while (iterator.hasNext())
2200          {
2201            final Long value = iterator.next();
2202            addMonitorAttribute(attrs,
2203                 "modifyOpsCount-" + lastValue + '-' + value,
2204                 INFO_PROCESSING_TIME_DISPNAME_MODIFY_COUNT.get(lastValue, value),
2205                 INFO_PROCESSING_TIME_DESC_MODIFY_COUNT.get(lastValue, value),
2206                 modifyOpsCount.get(lastValue));
2207    
2208            lastValue = value;
2209            if (! iterator.hasNext())
2210            {
2211              addMonitorAttribute(attrs,
2212                   "modifyOpsCount-" + lastValue,
2213                   INFO_PROCESSING_TIME_DISPNAME_MODIFY_COUNT_LAST.get(lastValue),
2214                   INFO_PROCESSING_TIME_DESC_MODIFY_COUNT_LAST.get(lastValue),
2215                   modifyOpsCount.get(lastValue));
2216            }
2217          }
2218        }
2219    
2220        if (! modifyOpsPercent.isEmpty())
2221        {
2222          final Iterator<Long> iterator = modifyOpsPercent.keySet().iterator();
2223          Long lastValue = iterator.next();
2224    
2225          while (iterator.hasNext())
2226          {
2227            final Long value = iterator.next();
2228            addMonitorAttribute(attrs,
2229                 "modifyOpsPct-" + lastValue + '-' + value,
2230                 INFO_PROCESSING_TIME_DISPNAME_MODIFY_PCT.get(lastValue, value),
2231                 INFO_PROCESSING_TIME_DESC_MODIFY_PCT.get(lastValue, value),
2232                 modifyOpsPercent.get(lastValue));
2233    
2234            lastValue = value;
2235            if (! iterator.hasNext())
2236            {
2237              addMonitorAttribute(attrs,
2238                   "modifyOpsPct-" + lastValue,
2239                   INFO_PROCESSING_TIME_DISPNAME_MODIFY_PCT_LAST.get(lastValue),
2240                   INFO_PROCESSING_TIME_DESC_MODIFY_PCT_LAST.get(lastValue),
2241                   modifyOpsPercent.get(lastValue));
2242            }
2243          }
2244        }
2245    
2246        if (! modifyOpsAggregatePercent.isEmpty())
2247        {
2248          final Iterator<Long> iterator =
2249               modifyOpsAggregatePercent.keySet().iterator();
2250          Long lastValue = iterator.next();
2251    
2252          while (iterator.hasNext())
2253          {
2254            final Long value = iterator.next();
2255            addMonitorAttribute(attrs,
2256                 "modifyOpsAggrPct-" + lastValue + '-' + value,
2257                 INFO_PROCESSING_TIME_DISPNAME_MODIFY_AGGR_PCT.get(lastValue,
2258                                                                   value),
2259                 INFO_PROCESSING_TIME_DESC_MODIFY_AGGR_PCT.get(lastValue, value),
2260                 modifyOpsAggregatePercent.get(lastValue));
2261    
2262            lastValue = value;
2263          }
2264        }
2265    
2266        if (modifyDNOpsTotalCount != null)
2267        {
2268          addMonitorAttribute(attrs,
2269               ATTR_MODIFY_DN_TOTAL_COUNT,
2270               INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_TOTAL_COUNT.get(),
2271               INFO_PROCESSING_TIME_DESC_MODIFY_DN_TOTAL_COUNT.get(),
2272               modifyDNOpsTotalCount);
2273        }
2274    
2275        if (modifyDNOpsAvgResponseTimeMillis != null)
2276        {
2277          addMonitorAttribute(attrs,
2278               ATTR_MODIFY_DN_AVERAGE_RESPONSE_TIME_MS,
2279               INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_TOTAL_TIME.get(),
2280               INFO_PROCESSING_TIME_DESC_MODIFY_DN_TOTAL_TIME.get(),
2281               modifyDNOpsAvgResponseTimeMillis);
2282        }
2283    
2284        if (! modifyDNOpsCount.isEmpty())
2285        {
2286          final Iterator<Long> iterator = modifyDNOpsCount.keySet().iterator();
2287          Long lastValue = iterator.next();
2288    
2289          while (iterator.hasNext())
2290          {
2291            final Long value = iterator.next();
2292            addMonitorAttribute(attrs,
2293                 "modifyDNOpsCount-" + lastValue + '-' + value,
2294                 INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_COUNT.get(lastValue,
2295                                                                   value),
2296                 INFO_PROCESSING_TIME_DESC_MODIFY_DN_COUNT.get(lastValue, value),
2297                 modifyDNOpsCount.get(lastValue));
2298    
2299            lastValue = value;
2300            if (! iterator.hasNext())
2301            {
2302              addMonitorAttribute(attrs,
2303                   "modifyDNOpsCount-" + lastValue,
2304                   INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_COUNT_LAST.get(
2305                        lastValue),
2306                   INFO_PROCESSING_TIME_DESC_MODIFY_DN_COUNT_LAST.get(lastValue),
2307                   modifyDNOpsCount.get(lastValue));
2308            }
2309          }
2310        }
2311    
2312        if (! modifyDNOpsPercent.isEmpty())
2313        {
2314          final Iterator<Long> iterator = modifyDNOpsPercent.keySet().iterator();
2315          Long lastValue = iterator.next();
2316    
2317          while (iterator.hasNext())
2318          {
2319            final Long value = iterator.next();
2320            addMonitorAttribute(attrs,
2321                 "modifyDNOpsPct-" + lastValue + '-' + value,
2322                 INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_PCT.get(lastValue, value),
2323                 INFO_PROCESSING_TIME_DESC_MODIFY_DN_PCT.get(lastValue, value),
2324                 modifyDNOpsPercent.get(lastValue));
2325    
2326            lastValue = value;
2327            if (! iterator.hasNext())
2328            {
2329              addMonitorAttribute(attrs,
2330                   "modifyDNOpsPct-" + lastValue,
2331                   INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_PCT_LAST.get(lastValue),
2332                   INFO_PROCESSING_TIME_DESC_MODIFY_DN_PCT_LAST.get(lastValue),
2333                   modifyDNOpsPercent.get(lastValue));
2334            }
2335          }
2336        }
2337    
2338        if (! modifyDNOpsAggregatePercent.isEmpty())
2339        {
2340          final Iterator<Long> iterator =
2341               modifyDNOpsAggregatePercent.keySet().iterator();
2342          Long lastValue = iterator.next();
2343    
2344          while (iterator.hasNext())
2345          {
2346            final Long value = iterator.next();
2347            addMonitorAttribute(attrs,
2348                 "modifyDNOpsAggrPct-" + lastValue + '-' + value,
2349                 INFO_PROCESSING_TIME_DISPNAME_MODIFY_DN_AGGR_PCT.get(lastValue,
2350                                                                      value),
2351                 INFO_PROCESSING_TIME_DESC_MODIFY_DN_AGGR_PCT.get(lastValue, value),
2352                 modifyDNOpsAggregatePercent.get(lastValue));
2353    
2354            lastValue = value;
2355          }
2356        }
2357    
2358        if (searchOpsTotalCount != null)
2359        {
2360          addMonitorAttribute(attrs,
2361               ATTR_SEARCH_TOTAL_COUNT,
2362               INFO_PROCESSING_TIME_DISPNAME_SEARCH_TOTAL_COUNT.get(),
2363               INFO_PROCESSING_TIME_DESC_SEARCH_TOTAL_COUNT.get(),
2364               searchOpsTotalCount);
2365        }
2366    
2367        if (searchOpsAvgResponseTimeMillis != null)
2368        {
2369          addMonitorAttribute(attrs,
2370               ATTR_SEARCH_AVERAGE_RESPONSE_TIME_MS,
2371               INFO_PROCESSING_TIME_DISPNAME_SEARCH_TOTAL_TIME.get(),
2372               INFO_PROCESSING_TIME_DESC_SEARCH_TOTAL_TIME.get(),
2373               searchOpsAvgResponseTimeMillis);
2374        }
2375    
2376        if (! searchOpsCount.isEmpty())
2377        {
2378          final Iterator<Long> iterator = searchOpsCount.keySet().iterator();
2379          Long lastValue = iterator.next();
2380    
2381          while (iterator.hasNext())
2382          {
2383            final Long value = iterator.next();
2384            addMonitorAttribute(attrs,
2385                 "searchOpsCount-" + lastValue + '-' + value,
2386                 INFO_PROCESSING_TIME_DISPNAME_SEARCH_COUNT.get(lastValue, value),
2387                 INFO_PROCESSING_TIME_DESC_SEARCH_COUNT.get(lastValue, value),
2388                 searchOpsCount.get(lastValue));
2389    
2390            lastValue = value;
2391            if (! iterator.hasNext())
2392            {
2393              addMonitorAttribute(attrs,
2394                   "searchOpsCount-" + lastValue,
2395                   INFO_PROCESSING_TIME_DISPNAME_SEARCH_COUNT_LAST.get(lastValue),
2396                   INFO_PROCESSING_TIME_DESC_SEARCH_COUNT_LAST.get(lastValue),
2397                   searchOpsCount.get(lastValue));
2398            }
2399          }
2400        }
2401    
2402        if (! searchOpsPercent.isEmpty())
2403        {
2404          final Iterator<Long> iterator = searchOpsPercent.keySet().iterator();
2405          Long lastValue = iterator.next();
2406    
2407          while (iterator.hasNext())
2408          {
2409            final Long value = iterator.next();
2410            addMonitorAttribute(attrs,
2411                 "searchOpsPct-" + lastValue + '-' + value,
2412                 INFO_PROCESSING_TIME_DISPNAME_SEARCH_PCT.get(lastValue, value),
2413                 INFO_PROCESSING_TIME_DESC_SEARCH_PCT.get(lastValue, value),
2414                 searchOpsPercent.get(lastValue));
2415    
2416            lastValue = value;
2417            if (! iterator.hasNext())
2418            {
2419              addMonitorAttribute(attrs,
2420                   "searchOpsPct-" + lastValue,
2421                   INFO_PROCESSING_TIME_DISPNAME_SEARCH_PCT_LAST.get(lastValue),
2422                   INFO_PROCESSING_TIME_DESC_SEARCH_PCT_LAST.get(lastValue),
2423                   searchOpsPercent.get(lastValue));
2424            }
2425          }
2426        }
2427    
2428        if (! searchOpsAggregatePercent.isEmpty())
2429        {
2430          final Iterator<Long> iterator =
2431               searchOpsAggregatePercent.keySet().iterator();
2432          Long lastValue = iterator.next();
2433    
2434          while (iterator.hasNext())
2435          {
2436            final Long value = iterator.next();
2437            addMonitorAttribute(attrs,
2438                 "searchOpsAggrPct-" + lastValue + '-' + value,
2439                 INFO_PROCESSING_TIME_DISPNAME_SEARCH_AGGR_PCT.get(lastValue,
2440                                                                   value),
2441                 INFO_PROCESSING_TIME_DESC_SEARCH_AGGR_PCT.get(lastValue, value),
2442                 searchOpsAggregatePercent.get(lastValue));
2443    
2444            lastValue = value;
2445          }
2446        }
2447    
2448        return Collections.unmodifiableMap(attrs);
2449      }
2450    }