001    /*
002     * Copyright 2014-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.Date;
027    import java.util.LinkedHashMap;
028    import java.util.List;
029    import java.util.Map;
030    
031    import com.unboundid.ldap.sdk.Entry;
032    import com.unboundid.ldap.sdk.unboundidds.AlarmSeverity;
033    import com.unboundid.util.NotExtensible;
034    import com.unboundid.util.ThreadSafety;
035    import com.unboundid.util.ThreadSafetyLevel;
036    
037    import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
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 the base class for gauge monitor entries, which provide
049     * information common to all types of gauges.  Subclasses may provide more
050     * specific information for that specific type of gauge.
051     */
052    @NotExtensible()
053    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
054    public class GaugeMonitorEntry
055           extends MonitorEntry
056    {
057      /**
058       * The base structural object class used in gauge monitor entries.
059       */
060      static final String GAUGE_MONITOR_OC = "ds-gauge-monitor-entry";
061    
062    
063    
064      /**
065       * The serial version UID for this serializable class.
066       */
067      private static final long   serialVersionUID = -6092840651638645538L;
068    
069    
070    
071      // The current severity for the gauge.
072      private final AlarmSeverity currentSeverity;
073    
074      // The previous severity for the gauge.
075      private final AlarmSeverity previousSeverity;
076    
077      // The time the gauge entered the current severity.
078      private final Date currentSeverityStartTime;
079    
080      // The time the gauge last exited the critical state.
081      private final Date lastCriticalStateEndTime;
082    
083      // The time the gauge last entered the critical state.
084      private final Date lastCriticalStateStartTime;
085    
086      // The time the gauge last exited the major state.
087      private final Date lastMajorStateEndTime;
088    
089      // The time the gauge last entered the major state.
090      private final Date lastMajorStateStartTime;
091    
092      // The time the gauge last exited the minor state.
093      private final Date lastMinorStateEndTime;
094    
095      // The time the gauge last entered the minor state.
096      private final Date lastMinorStateStartTime;
097    
098      // The time the gauge last exited the normal state.
099      private final Date lastNormalStateEndTime;
100    
101      // The time the gauge last entered the normal state.
102      private final Date lastNormalStateStartTime;
103    
104      // The time the gauge last exited the warning state.
105      private final Date lastWarningStateEndTime;
106    
107      // The time the gauge last entered the normal state.
108      private final Date lastWarningStateStartTime;
109    
110      // The time the gauge information was initialized.
111      private final Date initTime;
112    
113      // The time the gauge information was last updated.
114      private final Date updateTime;
115    
116      // The error messages.
117      private final List<String> errorMessages;
118    
119      // The current severity duration in milliseconds.
120      private final Long currentSeverityDurationMillis;
121    
122      // The last critical state duration in milliseconds.
123      private final Long lastCriticalStateDurationMillis;
124    
125      // The last major state duration in milliseconds.
126      private final Long lastMajorStateDurationMillis;
127    
128      // The last minor state duration in milliseconds.
129      private final Long lastMinorStateDurationMillis;
130    
131      // The last normal state duration in milliseconds.
132      private final Long lastNormalStateDurationMillis;
133    
134      // The last warning state duration in milliseconds.
135      private final Long lastWarningStateDurationMillis;
136    
137      // The number of samples taken in the current interval.
138      private final Long samplesThisInterval;
139    
140      // The total critical state duration in milliseconds.
141      private final Long totalCriticalStateDurationMillis;
142    
143      // The total major state duration in milliseconds.
144      private final Long totalMajorStateDurationMillis;
145    
146      // The total minor state duration in milliseconds.
147      private final Long totalMinorStateDurationMillis;
148    
149      // The total normal state duration in milliseconds.
150      private final Long totalNormalStateDurationMillis;
151    
152      // The total warning state duration in milliseconds.
153      private final Long totalWarningStateDurationMillis;
154    
155      // The string representation of the current severity duration.
156      private final String currentSeverityDurationString;
157    
158      // The name for the gauge.
159      private final String gaugeName;
160    
161      // The string representation of the last critical state duration.
162      private final String lastCriticalStateDurationString;
163    
164      // The string representation of the last major state duration.
165      private final String lastMajorStateDurationString;
166    
167      // The string representation of the last minor state duration.
168      private final String lastMinorStateDurationString;
169    
170      // The string representation of the last normal state duration.
171      private final String lastNormalStateDurationString;
172    
173      // The string representation of the last warning state duration.
174      private final String lastWarningStateDurationString;
175    
176      // The resource for the gauge.
177      private final String resource;
178    
179      // The resource type for the gauge.
180      private final String resourceType;
181    
182      // The summary message.
183      private final String summary;
184    
185      // The string representation of the total critical state duration.
186      private final String totalCriticalStateDurationString;
187    
188      // The string representation of the total major state duration.
189      private final String totalMajorStateDurationString;
190    
191      // The string representation of the total minor state duration.
192      private final String totalMinorStateDurationString;
193    
194      // The string representation of the total normal state duration.
195      private final String totalNormalStateDurationString;
196    
197      // The string representation of the total warning state duration.
198      private final String totalWarningStateDurationString;
199    
200    
201    
202      /**
203       * Creates a new gauge monitor entry from the provided entry.
204       *
205       * @param  entry  The entry to be parsed as a gauge monitor entry.  It must
206       *                not be {@code null}.
207       */
208      public GaugeMonitorEntry(final Entry entry)
209      {
210        super(entry);
211    
212        gaugeName = getString("gauge-name");
213        resource = getString("resource");
214        resourceType = getString("resource-type");
215    
216        final String currentSeverityStr = getString("severity");
217        if (currentSeverityStr == null)
218        {
219          currentSeverity = null;
220        }
221        else
222        {
223          currentSeverity = AlarmSeverity.forName(currentSeverityStr);
224        }
225    
226        final String previousSeverityStr = getString("previous-severity");
227        if (previousSeverityStr == null)
228        {
229          previousSeverity = null;
230        }
231        else
232        {
233          previousSeverity = AlarmSeverity.forName(previousSeverityStr);
234        }
235    
236        summary = getString("summary");
237        errorMessages = getStrings("error-message");
238        initTime = getDate("gauge-init-time");
239        updateTime = getDate("update-time");
240        samplesThisInterval = getLong("samples-this-interval");
241    
242        currentSeverityStartTime = getDate("current-severity-start-time");
243        currentSeverityDurationString = getString("current-severity-duration");
244        currentSeverityDurationMillis = getLong("current-severity-duration-millis");
245    
246        lastNormalStateStartTime = getDate("last-normal-state-start-time");
247        lastNormalStateEndTime = getDate("last-normal-state-end-time");
248        lastNormalStateDurationString = getString("last-normal-state-duration");
249        lastNormalStateDurationMillis =
250             getLong("last-normal-state-duration-millis");
251        totalNormalStateDurationString = getString("total-normal-state-duration");
252        totalNormalStateDurationMillis =
253             getLong("total-normal-state-duration-millis");
254    
255        lastWarningStateStartTime = getDate("last-warning-state-start-time");
256        lastWarningStateEndTime = getDate("last-warning-state-end-time");
257        lastWarningStateDurationString = getString("last-warning-state-duration");
258        lastWarningStateDurationMillis =
259             getLong("last-warning-state-duration-millis");
260        totalWarningStateDurationString = getString("total-warning-state-duration");
261        totalWarningStateDurationMillis =
262             getLong("total-warning-state-duration-millis");
263    
264        lastMinorStateStartTime = getDate("last-minor-state-start-time");
265        lastMinorStateEndTime = getDate("last-minor-state-end-time");
266        lastMinorStateDurationString = getString("last-minor-state-duration");
267        lastMinorStateDurationMillis = getLong("last-minor-state-duration-millis");
268        totalMinorStateDurationString = getString("total-minor-state-duration");
269        totalMinorStateDurationMillis =
270             getLong("total-minor-state-duration-millis");
271    
272        lastMajorStateStartTime = getDate("last-major-state-start-time");
273        lastMajorStateEndTime = getDate("last-major-state-end-time");
274        lastMajorStateDurationString = getString("last-major-state-duration");
275        lastMajorStateDurationMillis = getLong("last-major-state-duration-millis");
276        totalMajorStateDurationString = getString("total-major-state-duration");
277        totalMajorStateDurationMillis =
278             getLong("total-major-state-duration-millis");
279    
280        lastCriticalStateStartTime = getDate("last-critical-state-start-time");
281        lastCriticalStateEndTime = getDate("last-critical-state-end-time");
282        lastCriticalStateDurationString = getString("last-critical-state-duration");
283        lastCriticalStateDurationMillis =
284             getLong("last-critical-state-duration-millis");
285        totalCriticalStateDurationString =
286             getString("total-critical-state-duration");
287        totalCriticalStateDurationMillis =
288             getLong("total-critical-state-duration-millis");
289      }
290    
291    
292    
293      /**
294       * Retrieves the name for the gauge, if available.
295       *
296       * @return  The name for the gauge, or {@code null} if it was not included
297       *          in the monitor entry.
298       */
299      public final String getGaugeName()
300      {
301        return gaugeName;
302      }
303    
304    
305    
306      /**
307       * Retrieves the resource for the gauge, if available.
308       *
309       * @return  The resource for the gauge, or {@code null} if it was not included
310       *          in the monitor entry.
311       */
312      public final String getResource()
313      {
314        return resource;
315      }
316    
317    
318    
319      /**
320       * Retrieves the resource type for the gauge, if available.
321       *
322       * @return  The resource type for the gauge, or {@code null} if it was not
323       *          included in the monitor entry.
324       */
325      public final String getResourceType()
326      {
327        return resourceType;
328      }
329    
330    
331    
332      /**
333       * Retrieves the current severity for the gauge, if available.
334       *
335       * @return  The current severity for the gauge, or {@code null} if it was not
336       *          included in the monitor entry.
337       */
338      public final AlarmSeverity getCurrentSeverity()
339      {
340        return currentSeverity;
341      }
342    
343    
344    
345      /**
346       * Retrieves the previous severity for the gauge, if available.
347       *
348       * @return  The previous severity for the gauge, or {@code null} if it was not
349       *          included in the monitor entry.
350       */
351      public final AlarmSeverity getPreviousSeverity()
352      {
353        return previousSeverity;
354      }
355    
356    
357    
358      /**
359       * Retrieves the summary message for the gauge, if available.
360       *
361       * @return  The summary message for the gauge, or {@code null} if it was not
362       *          included in the monitor entry.
363       */
364      public final String getSummary()
365      {
366        return summary;
367      }
368    
369    
370    
371      /**
372       * Retrieves the error messages for the gauge, if available.
373       *
374       * @return  The list of error messages for the gauge, or an empty list if it
375       *          was not included in the monitor entry.
376       */
377      public final List<String> getErrorMessages()
378      {
379        return errorMessages;
380      }
381    
382    
383    
384      /**
385       * Retrieves the time the gauge was initialized, if available.
386       *
387       * @return  The time the gauge was initialized, or {@code null} if it was not
388       *          included in the monitor entry.
389       */
390      public final Date getInitTime()
391      {
392        return initTime;
393      }
394    
395    
396    
397      /**
398       * Retrieves the time the gauge was last updated, if available.
399       *
400       * @return  The time the gauge was last updated, or {@code null} if it was not
401       *          included in the monitor entry.
402       */
403      public final Date getUpdateTime()
404      {
405        return updateTime;
406      }
407    
408    
409    
410      /**
411       * Retrieves the number of samples taken in the current interval, if
412       * available.
413       *
414       * @return  The number of samples taken in the current interval, or
415       *          {@code null} if it was not included in the monitor entry.
416       */
417      public final Long getSamplesThisInterval()
418      {
419        return samplesThisInterval;
420      }
421    
422    
423    
424      /**
425       * Retrieves the time the gauge entered the current severity, if available.
426       *
427       * @return  The time the gauge entered the current severity, or {@code null}
428       *          if it was not included in the monitor entry.
429       */
430      public final Date getCurrentSeverityStartTime()
431      {
432        return currentSeverityStartTime;
433      }
434    
435    
436    
437      /**
438       * Retrieves the current severity duration as a human-readable string, if
439       * available.
440       *
441       * @return  The current severity duration as a human-readable string, or
442       *          {@code null} if it was not included in the monitor entry.
443       */
444      public final String getCurrentSeverityDurationString()
445      {
446        return currentSeverityDurationString;
447      }
448    
449    
450    
451      /**
452       * Retrieves the current severity duration in milliseconds, if available.
453       *
454       * @return  The current severity duration in milliseconds, or {@code null} if
455       *          it was not included in the monitor entry.
456       */
457      public final Long getCurrentSeverityDurationMillis()
458      {
459        return currentSeverityDurationMillis;
460      }
461    
462    
463    
464      /**
465       * Retrieves the time the gauge last entered the normal state, if available.
466       *
467       * @return  The time the gauge last entered the normal state, or {@code null}
468       *          if it was not included in the monitor entry.
469       */
470      public final Date getLastNormalStateStartTime()
471      {
472        return lastNormalStateStartTime;
473      }
474    
475    
476    
477      /**
478       * Retrieves the time the gauge last exited the normal state, if available.
479       *
480       * @return  The time the gauge last exited the normal state, or {@code null}
481       *          if it was not included in the monitor entry.
482       */
483      public final Date getLastNormalStateEndTime()
484      {
485        return lastNormalStateEndTime;
486      }
487    
488    
489    
490      /**
491       * Retrieves the duration of the last normal state as a human-readable string,
492       * if available.
493       *
494       * @return  The duration of the last normal state as a human-readable string,
495       *          or {@code null} if it was not included in the monitor entry.
496       */
497      public final String getLastNormalStateDurationString()
498      {
499        return lastNormalStateDurationString;
500      }
501    
502    
503    
504      /**
505       * Retrieves the duration of the last normal state in milliseconds, if
506       * available.
507       *
508       * @return  The duration of the last normal state in milliseconds, or
509       *          {@code null} if it was not included in the monitor entry.
510       */
511      public final Long getLastNormalStateDurationMillis()
512      {
513        return lastNormalStateDurationMillis;
514      }
515    
516    
517    
518      /**
519       * Retrieves the total length of time the gauge has been in the normal state
520       * as a human-readable string, if available.
521       *
522       * @return  The total length of time the gauge has been in the normal state as
523       *          a human-readable string, or {@code null} if it was not included in
524       *          the monitor entry.
525       */
526      public final String getTotalNormalStateDurationString()
527      {
528        return totalNormalStateDurationString;
529      }
530    
531    
532    
533      /**
534       * Retrieves the total length of time the gauge has been in the normal state
535       * in milliseconds, if available.
536       *
537       * @return  The total length of time the gauge has been in the normal state in
538       *          milliseconds, or {@code null} if it was not included in the
539       *          monitor entry.
540       */
541      public final Long getTotalNormalStateDurationMillis()
542      {
543        return totalNormalStateDurationMillis;
544      }
545    
546    
547    
548      /**
549       * Retrieves the time the gauge last entered the warning state, if available.
550       *
551       * @return  The time the gauge last entered the warning state, or {@code null}
552       *          if it was not included in the monitor entry.
553       */
554      public final Date getLastWarningStateStartTime()
555      {
556        return lastWarningStateStartTime;
557      }
558    
559    
560    
561      /**
562       * Retrieves the time the gauge last exited the warning state, if available.
563       *
564       * @return  The time the gauge last exited the warning state, or {@code null}
565       *          if it was not included in the monitor entry.
566       */
567      public final Date getLastWarningStateEndTime()
568      {
569        return lastWarningStateEndTime;
570      }
571    
572    
573    
574      /**
575       * Retrieves the duration of the last warning state as a human-readable
576       * string, if available.
577       *
578       * @return  The duration of the last warning state as a human-readable string,
579       *          or {@code null} if it was not included in the monitor entry.
580       */
581      public final String getLastWarningStateDurationString()
582      {
583        return lastWarningStateDurationString;
584      }
585    
586    
587    
588      /**
589       * Retrieves the duration of the last warning state in milliseconds, if
590       * available.
591       *
592       * @return  The duration of the last warning state in milliseconds, or
593       *          {@code null} if it was not included in the monitor entry.
594       */
595      public final Long getLastWarningStateDurationMillis()
596      {
597        return lastWarningStateDurationMillis;
598      }
599    
600    
601    
602      /**
603       * Retrieves the total length of time the gauge has been in the warning state
604       * as a human-readable string, if available.
605       *
606       * @return  The total length of time the gauge has been in the warning state
607       *          as a human-readable string, or {@code null} if it was not included
608       *          in the monitor entry.
609       */
610      public final String getTotalWarningStateDurationString()
611      {
612        return totalWarningStateDurationString;
613      }
614    
615    
616    
617      /**
618       * Retrieves the total length of time the gauge has been in the warning state
619       * in milliseconds, if available.
620       *
621       * @return  The total length of time the gauge has been in the warning state
622       *          in milliseconds, or {@code null} if it was not included in the
623       *          monitor entry.
624       */
625      public final Long getTotalWarningStateDurationMillis()
626      {
627        return totalWarningStateDurationMillis;
628      }
629    
630    
631    
632      /**
633       * Retrieves the time the gauge last entered the minor state, if available.
634       *
635       * @return  The time the gauge last entered the minor state, or {@code null}
636       *          if it was not included in the monitor entry.
637       */
638      public final Date getLastMinorStateStartTime()
639      {
640        return lastMinorStateStartTime;
641      }
642    
643    
644    
645      /**
646       * Retrieves the time the gauge last exited the minor state, if available.
647       *
648       * @return  The time the gauge last exited the minor state, or {@code null}
649       *          if it was not included in the monitor entry.
650       */
651      public final Date getLastMinorStateEndTime()
652      {
653        return lastMinorStateEndTime;
654      }
655    
656    
657    
658      /**
659       * Retrieves the duration of the last minor state as a human-readable string,
660       * if available.
661       *
662       * @return  The duration of the last minor state as a human-readable string,
663       *          or {@code null} if it was not included in the monitor entry.
664       */
665      public final String getLastMinorStateDurationString()
666      {
667        return lastMinorStateDurationString;
668      }
669    
670    
671    
672      /**
673       * Retrieves the duration of the last minor state in milliseconds, if
674       * available.
675       *
676       * @return  The duration of the last minor state in milliseconds, or
677       *          {@code null} if it was not included in the monitor entry.
678       */
679      public final Long getLastMinorStateDurationMillis()
680      {
681        return lastMinorStateDurationMillis;
682      }
683    
684    
685    
686      /**
687       * Retrieves the total length of time the gauge has been in the minor state
688       * as a human-readable string, if available.
689       *
690       * @return  The total length of time the gauge has been in the minor state as
691       *          a human-readable string, or {@code null} if it was not included in
692       *          the monitor entry.
693       */
694      public final String getTotalMinorStateDurationString()
695      {
696        return totalMinorStateDurationString;
697      }
698    
699    
700    
701      /**
702       * Retrieves the total length of time the gauge has been in the minor state
703       * in milliseconds, if available.
704       *
705       * @return  The total length of time the gauge has been in the minor state in
706       *          milliseconds, or {@code null} if it was not included in the
707       *          monitor entry.
708       */
709      public final Long getTotalMinorStateDurationMillis()
710      {
711        return totalMinorStateDurationMillis;
712      }
713    
714    
715    
716      /**
717       * Retrieves the time the gauge last entered the major state, if available.
718       *
719       * @return  The time the gauge last entered the major state, or {@code null}
720       *          if it was not included in the monitor entry.
721       */
722      public final Date getLastMajorStateStartTime()
723      {
724        return lastMajorStateStartTime;
725      }
726    
727    
728    
729      /**
730       * Retrieves the time the gauge last exited the major state, if available.
731       *
732       * @return  The time the gauge last exited the major state, or {@code null}
733       *          if it was not included in the monitor entry.
734       */
735      public final Date getLastMajorStateEndTime()
736      {
737        return lastMajorStateEndTime;
738      }
739    
740    
741    
742      /**
743       * Retrieves the duration of the last major state as a human-readable string,
744       * if available.
745       *
746       * @return  The duration of the last major state as a human-readable string,
747       *          or {@code null} if it was not included in the monitor entry.
748       */
749      public final String getLastMajorStateDurationString()
750      {
751        return lastMajorStateDurationString;
752      }
753    
754    
755    
756      /**
757       * Retrieves the duration of the last major state in milliseconds, if
758       * available.
759       *
760       * @return  The duration of the last major state in milliseconds, or
761       *          {@code null} if it was not included in the monitor entry.
762       */
763      public final Long getLastMajorStateDurationMillis()
764      {
765        return lastMajorStateDurationMillis;
766      }
767    
768    
769    
770      /**
771       * Retrieves the total length of time the gauge has been in the major state
772       * as a human-readable string, if available.
773       *
774       * @return  The total length of time the gauge has been in the major state as
775       *          a human-readable string, or {@code null} if it was not included in
776       *          the monitor entry.
777       */
778      public final String getTotalMajorStateDurationString()
779      {
780        return totalMajorStateDurationString;
781      }
782    
783    
784    
785      /**
786       * Retrieves the total length of time the gauge has been in the major state
787       * in milliseconds, if available.
788       *
789       * @return  The total length of time the gauge has been in the major state in
790       *          milliseconds, or {@code null} if it was not included in the
791       *          monitor entry.
792       */
793      public final Long getTotalMajorStateDurationMillis()
794      {
795        return totalMajorStateDurationMillis;
796      }
797    
798    
799    
800      /**
801       * Retrieves the time the gauge last entered the critical state, if available.
802       *
803       * @return  The time the gauge last entered the critical state, or
804       *          {@code null} if it was not included in the monitor entry.
805       */
806      public final Date getLastCriticalStateStartTime()
807      {
808        return lastCriticalStateStartTime;
809      }
810    
811    
812    
813      /**
814       * Retrieves the time the gauge last exited the critical state, if available.
815       *
816       * @return  The time the gauge last exited the critical state, or {@code null}
817       *          if it was not included in the monitor entry.
818       */
819      public final Date getLastCriticalStateEndTime()
820      {
821        return lastCriticalStateEndTime;
822      }
823    
824    
825    
826      /**
827       * Retrieves the duration of the last critical state as a human-readable
828       * string, if available.
829       *
830       * @return  The duration of the last critical state as a human-readable
831       *          string, or {@code null} if it was not included in the monitor
832       *          entry.
833       */
834      public final String getLastCriticalStateDurationString()
835      {
836        return lastCriticalStateDurationString;
837      }
838    
839    
840    
841      /**
842       * Retrieves the duration of the last critical state in milliseconds, if
843       * available.
844       *
845       * @return  The duration of the last critical state in milliseconds, or
846       *          {@code null} if it was not included in the monitor entry.
847       */
848      public final Long getLastCriticalStateDurationMillis()
849      {
850        return lastCriticalStateDurationMillis;
851      }
852    
853    
854    
855      /**
856       * Retrieves the total length of time the gauge has been in the critical state
857       * as a human-readable string, if available.
858       *
859       * @return  The total length of time the gauge has been in the critical state
860       *          as a human-readable string, or {@code null} if it was not included
861       *          in the monitor entry.
862       */
863      public final String getTotalCriticalStateDurationString()
864      {
865        return totalCriticalStateDurationString;
866      }
867    
868    
869    
870      /**
871       * Retrieves the total length of time the gauge has been in the critical state
872       * in milliseconds, if available.
873       *
874       * @return  The total length of time the gauge has been in the critical state
875       *          in milliseconds, or {@code null} if it was not included in the
876       *          monitor entry.
877       */
878      public final Long getTotalCriticalStateDurationMillis()
879      {
880        return totalCriticalStateDurationMillis;
881      }
882    
883    
884    
885      /**
886       * {@inheritDoc}
887       */
888      @Override()
889      public String getMonitorDisplayName()
890      {
891        return INFO_GAUGE_MONITOR_DISPNAME.get();
892      }
893    
894    
895    
896      /**
897       * {@inheritDoc}
898       */
899      @Override()
900      public String getMonitorDescription()
901      {
902        return INFO_GAUGE_MONITOR_DESC.get();
903      }
904    
905    
906    
907      /**
908       * {@inheritDoc}
909       */
910      @Override()
911      public Map<String,MonitorAttribute> getMonitorAttributes()
912      {
913        final LinkedHashMap<String,MonitorAttribute> attrs =
914             new LinkedHashMap<String,MonitorAttribute>(43);
915    
916        if (gaugeName != null)
917        {
918          addMonitorAttribute(attrs,
919               "gauge-name",
920               INFO_GAUGE_DISPNAME_GAUGE_NAME.get(),
921               INFO_GAUGE_DESC_GAUGE_NAME.get(),
922               gaugeName);
923        }
924    
925        if (resource != null)
926        {
927          addMonitorAttribute(attrs,
928               "resource",
929               INFO_GAUGE_DISPNAME_RESOURCE.get(),
930               INFO_GAUGE_DESC_RESOURCE.get(),
931               resource);
932        }
933    
934        if (resourceType != null)
935        {
936          addMonitorAttribute(attrs,
937               "resource-type",
938               INFO_GAUGE_DISPNAME_RESOURCE_TYPE.get(),
939               INFO_GAUGE_DESC_RESOURCE_TYPE.get(),
940               resourceType);
941        }
942    
943        if (currentSeverity != null)
944        {
945          addMonitorAttribute(attrs,
946               "severity",
947               INFO_GAUGE_DISPNAME_CURRENT_SEVERITY.get(),
948               INFO_GAUGE_DESC_CURRENT_SEVERITY.get(),
949               currentSeverity.name());
950        }
951    
952        if (previousSeverity != null)
953        {
954          addMonitorAttribute(attrs,
955               "previous-severity",
956               INFO_GAUGE_DISPNAME_PREVIOUS_SEVERITY.get(),
957               INFO_GAUGE_DESC_PREVIOUS_SEVERITY.get(),
958               previousSeverity.name());
959        }
960    
961        if (summary != null)
962        {
963          addMonitorAttribute(attrs,
964               "summary",
965               INFO_GAUGE_DISPNAME_SUMMARY.get(),
966               INFO_GAUGE_DESC_SUMMARY.get(),
967               summary);
968        }
969    
970        if (! errorMessages.isEmpty())
971        {
972          addMonitorAttribute(attrs,
973               "error-message",
974               INFO_GAUGE_DISPNAME_ERROR_MESSAGE.get(),
975               INFO_GAUGE_DESC_ERROR_MESSAGE.get(),
976               errorMessages);
977        }
978    
979        if (initTime != null)
980        {
981          addMonitorAttribute(attrs,
982               "gauge-init-time",
983               INFO_GAUGE_DISPNAME_INIT_TIME.get(),
984               INFO_GAUGE_DESC_INIT_TIME.get(),
985               initTime);
986        }
987    
988        if (updateTime != null)
989        {
990          addMonitorAttribute(attrs,
991               "update-time",
992               INFO_GAUGE_DISPNAME_UPDATE_TIME.get(),
993               INFO_GAUGE_DESC_UPDATE_TIME.get(),
994               updateTime);
995        }
996    
997        if (samplesThisInterval != null)
998        {
999          addMonitorAttribute(attrs,
1000               "samples-this-interval",
1001               INFO_GAUGE_DISPNAME_SAMPLES_THIS_INTERVAL.get(),
1002               INFO_GAUGE_DESC_SAMPLES_THIS_INTERVAL.get(),
1003               samplesThisInterval);
1004        }
1005    
1006        if (currentSeverityStartTime != null)
1007        {
1008          addMonitorAttribute(attrs,
1009               "current-severity-start-time",
1010               INFO_GAUGE_DISPNAME_CURRENT_START_TIME.get(),
1011               INFO_GAUGE_DESC_CURRENT_START_TIME.get(),
1012               currentSeverityStartTime);
1013        }
1014    
1015        if (currentSeverityDurationString != null)
1016        {
1017          addMonitorAttribute(attrs,
1018               "current-severity-duration",
1019               INFO_GAUGE_DISPNAME_CURRENT_DURATION_STRING.get(),
1020               INFO_GAUGE_DESC_CURRENT_DURATION_STRING.get(),
1021               currentSeverityDurationString);
1022        }
1023    
1024        if (currentSeverityDurationMillis != null)
1025        {
1026          addMonitorAttribute(attrs,
1027               "current-severity-duration-millis",
1028               INFO_GAUGE_DISPNAME_CURRENT_DURATION_MILLIS.get(),
1029               INFO_GAUGE_DESC_CURRENT_DURATION_MILLIS.get(),
1030               currentSeverityDurationMillis);
1031        }
1032    
1033        if (lastNormalStateStartTime != null)
1034        {
1035          addMonitorAttribute(attrs,
1036               "last-normal-state-start-time",
1037               INFO_GAUGE_DISPNAME_LAST_NORMAL_START_TIME.get(),
1038               INFO_GAUGE_DESC_LAST_NORMAL_START_TIME.get(),
1039               lastNormalStateStartTime);
1040        }
1041    
1042        if (lastNormalStateEndTime != null)
1043        {
1044          addMonitorAttribute(attrs,
1045               "last-normal-state-end-time",
1046               INFO_GAUGE_DISPNAME_LAST_NORMAL_END_TIME.get(),
1047               INFO_GAUGE_DESC_LAST_NORMAL_END_TIME.get(),
1048               lastNormalStateEndTime);
1049        }
1050    
1051        if (lastNormalStateDurationString != null)
1052        {
1053          addMonitorAttribute(attrs,
1054               "last-normal-state-duration",
1055               INFO_GAUGE_DISPNAME_LAST_NORMAL_DURATION_STRING.get(),
1056               INFO_GAUGE_DESC_LAST_NORMAL_DURATION_STRING.get(),
1057               lastNormalStateDurationString);
1058        }
1059    
1060        if (lastNormalStateDurationMillis != null)
1061        {
1062          addMonitorAttribute(attrs,
1063               "last-normal-state-duration-millis",
1064               INFO_GAUGE_DISPNAME_LAST_NORMAL_DURATION_MILLIS.get(),
1065               INFO_GAUGE_DESC_LAST_NORMAL_DURATION_MILLIS.get(),
1066               lastNormalStateDurationMillis);
1067        }
1068    
1069        if (totalNormalStateDurationString != null)
1070        {
1071          addMonitorAttribute(attrs,
1072               "total-normal-state-duration",
1073               INFO_GAUGE_DISPNAME_TOTAL_NORMAL_DURATION_STRING.get(),
1074               INFO_GAUGE_DESC_TOTAL_NORMAL_DURATION_STRING.get(),
1075               totalNormalStateDurationString);
1076        }
1077    
1078        if (totalNormalStateDurationMillis != null)
1079        {
1080          addMonitorAttribute(attrs,
1081               "total-normal-state-duration-millis",
1082               INFO_GAUGE_DISPNAME_TOTAL_NORMAL_DURATION_MILLIS.get(),
1083               INFO_GAUGE_DESC_TOTAL_NORMAL_DURATION_MILLIS.get(),
1084               totalNormalStateDurationMillis);
1085        }
1086    
1087        if (lastWarningStateStartTime != null)
1088        {
1089          addMonitorAttribute(attrs,
1090               "last-warning-state-start-time",
1091               INFO_GAUGE_DISPNAME_LAST_WARNING_START_TIME.get(),
1092               INFO_GAUGE_DESC_LAST_WARNING_START_TIME.get(),
1093               lastWarningStateStartTime);
1094        }
1095    
1096        if (lastWarningStateEndTime != null)
1097        {
1098          addMonitorAttribute(attrs,
1099               "last-warning-state-end-time",
1100               INFO_GAUGE_DISPNAME_LAST_WARNING_END_TIME.get(),
1101               INFO_GAUGE_DESC_LAST_WARNING_END_TIME.get(),
1102               lastWarningStateEndTime);
1103        }
1104    
1105        if (lastWarningStateDurationString != null)
1106        {
1107          addMonitorAttribute(attrs,
1108               "last-warning-state-duration",
1109               INFO_GAUGE_DISPNAME_LAST_WARNING_DURATION_STRING.get(),
1110               INFO_GAUGE_DESC_LAST_WARNING_DURATION_STRING.get(),
1111               lastWarningStateDurationString);
1112        }
1113    
1114        if (lastWarningStateDurationMillis != null)
1115        {
1116          addMonitorAttribute(attrs,
1117               "last-warning-state-duration-millis",
1118               INFO_GAUGE_DISPNAME_LAST_WARNING_DURATION_MILLIS.get(),
1119               INFO_GAUGE_DESC_LAST_WARNING_DURATION_MILLIS.get(),
1120               lastWarningStateDurationMillis);
1121        }
1122    
1123        if (totalWarningStateDurationString != null)
1124        {
1125          addMonitorAttribute(attrs,
1126               "total-warning-state-duration",
1127               INFO_GAUGE_DISPNAME_TOTAL_WARNING_DURATION_STRING.get(),
1128               INFO_GAUGE_DESC_TOTAL_WARNING_DURATION_STRING.get(),
1129               totalWarningStateDurationString);
1130        }
1131    
1132        if (totalWarningStateDurationMillis != null)
1133        {
1134          addMonitorAttribute(attrs,
1135               "total-warning-state-duration-millis",
1136               INFO_GAUGE_DISPNAME_TOTAL_WARNING_DURATION_MILLIS.get(),
1137               INFO_GAUGE_DESC_TOTAL_WARNING_DURATION_MILLIS.get(),
1138               totalWarningStateDurationMillis);
1139        }
1140    
1141        if (lastMinorStateStartTime != null)
1142        {
1143          addMonitorAttribute(attrs,
1144               "last-minor-state-start-time",
1145               INFO_GAUGE_DISPNAME_LAST_MINOR_START_TIME.get(),
1146               INFO_GAUGE_DESC_LAST_MINOR_START_TIME.get(),
1147               lastMinorStateStartTime);
1148        }
1149    
1150        if (lastMinorStateEndTime != null)
1151        {
1152          addMonitorAttribute(attrs,
1153               "last-minor-state-end-time",
1154               INFO_GAUGE_DISPNAME_LAST_MINOR_END_TIME.get(),
1155               INFO_GAUGE_DESC_LAST_MINOR_END_TIME.get(),
1156               lastMinorStateEndTime);
1157        }
1158    
1159        if (lastMinorStateDurationString != null)
1160        {
1161          addMonitorAttribute(attrs,
1162               "last-minor-state-duration",
1163               INFO_GAUGE_DISPNAME_LAST_MINOR_DURATION_STRING.get(),
1164               INFO_GAUGE_DESC_LAST_MINOR_DURATION_STRING.get(),
1165               lastMinorStateDurationString);
1166        }
1167    
1168        if (lastMinorStateDurationMillis != null)
1169        {
1170          addMonitorAttribute(attrs,
1171               "last-minor-state-duration-millis",
1172               INFO_GAUGE_DISPNAME_LAST_MINOR_DURATION_MILLIS.get(),
1173               INFO_GAUGE_DESC_LAST_MINOR_DURATION_MILLIS.get(),
1174               lastMinorStateDurationMillis);
1175        }
1176    
1177        if (totalMinorStateDurationString != null)
1178        {
1179          addMonitorAttribute(attrs,
1180               "total-minor-state-duration",
1181               INFO_GAUGE_DISPNAME_TOTAL_MINOR_DURATION_STRING.get(),
1182               INFO_GAUGE_DESC_TOTAL_MINOR_DURATION_STRING.get(),
1183               totalMinorStateDurationString);
1184        }
1185    
1186        if (totalMinorStateDurationMillis != null)
1187        {
1188          addMonitorAttribute(attrs,
1189               "total-minor-state-duration-millis",
1190               INFO_GAUGE_DISPNAME_TOTAL_MINOR_DURATION_MILLIS.get(),
1191               INFO_GAUGE_DESC_TOTAL_MINOR_DURATION_MILLIS.get(),
1192               totalMinorStateDurationMillis);
1193        }
1194    
1195        if (lastMajorStateStartTime != null)
1196        {
1197          addMonitorAttribute(attrs,
1198               "last-major-state-start-time",
1199               INFO_GAUGE_DISPNAME_LAST_MAJOR_START_TIME.get(),
1200               INFO_GAUGE_DESC_LAST_MAJOR_START_TIME.get(),
1201               lastMajorStateStartTime);
1202        }
1203    
1204        if (lastMajorStateEndTime != null)
1205        {
1206          addMonitorAttribute(attrs,
1207               "last-major-state-end-time",
1208               INFO_GAUGE_DISPNAME_LAST_MAJOR_END_TIME.get(),
1209               INFO_GAUGE_DESC_LAST_MAJOR_END_TIME.get(),
1210               lastMajorStateEndTime);
1211        }
1212    
1213        if (lastMajorStateDurationString != null)
1214        {
1215          addMonitorAttribute(attrs,
1216               "last-major-state-duration",
1217               INFO_GAUGE_DISPNAME_LAST_MAJOR_DURATION_STRING.get(),
1218               INFO_GAUGE_DESC_LAST_MAJOR_DURATION_STRING.get(),
1219               lastMajorStateDurationString);
1220        }
1221    
1222        if (lastMajorStateDurationMillis != null)
1223        {
1224          addMonitorAttribute(attrs,
1225               "last-major-state-duration-millis",
1226               INFO_GAUGE_DISPNAME_LAST_MAJOR_DURATION_MILLIS.get(),
1227               INFO_GAUGE_DESC_LAST_MAJOR_DURATION_MILLIS.get(),
1228               lastMajorStateDurationMillis);
1229        }
1230    
1231        if (totalMajorStateDurationString != null)
1232        {
1233          addMonitorAttribute(attrs,
1234               "total-major-state-duration",
1235               INFO_GAUGE_DISPNAME_TOTAL_MAJOR_DURATION_STRING.get(),
1236               INFO_GAUGE_DESC_TOTAL_MAJOR_DURATION_STRING.get(),
1237               totalMajorStateDurationString);
1238        }
1239    
1240        if (totalMajorStateDurationMillis != null)
1241        {
1242          addMonitorAttribute(attrs,
1243               "total-major-state-duration-millis",
1244               INFO_GAUGE_DISPNAME_TOTAL_MAJOR_DURATION_MILLIS.get(),
1245               INFO_GAUGE_DESC_TOTAL_MAJOR_DURATION_MILLIS.get(),
1246               totalMajorStateDurationMillis);
1247        }
1248    
1249        if (lastCriticalStateStartTime != null)
1250        {
1251          addMonitorAttribute(attrs,
1252               "last-critical-state-start-time",
1253               INFO_GAUGE_DISPNAME_LAST_CRITICAL_START_TIME.get(),
1254               INFO_GAUGE_DESC_LAST_CRITICAL_START_TIME.get(),
1255               lastCriticalStateStartTime);
1256        }
1257    
1258        if (lastCriticalStateEndTime != null)
1259        {
1260          addMonitorAttribute(attrs,
1261               "last-critical-state-end-time",
1262               INFO_GAUGE_DISPNAME_LAST_CRITICAL_END_TIME.get(),
1263               INFO_GAUGE_DESC_LAST_CRITICAL_END_TIME.get(),
1264               lastCriticalStateEndTime);
1265        }
1266    
1267        if (lastCriticalStateDurationString != null)
1268        {
1269          addMonitorAttribute(attrs,
1270               "last-critical-state-duration",
1271               INFO_GAUGE_DISPNAME_LAST_CRITICAL_DURATION_STRING.get(),
1272               INFO_GAUGE_DESC_LAST_CRITICAL_DURATION_STRING.get(),
1273               lastCriticalStateDurationString);
1274        }
1275    
1276        if (lastCriticalStateDurationMillis != null)
1277        {
1278          addMonitorAttribute(attrs,
1279               "last-critical-state-duration-millis",
1280               INFO_GAUGE_DISPNAME_LAST_CRITICAL_DURATION_MILLIS.get(),
1281               INFO_GAUGE_DESC_LAST_CRITICAL_DURATION_MILLIS.get(),
1282               lastCriticalStateDurationMillis);
1283        }
1284    
1285        if (totalCriticalStateDurationString != null)
1286        {
1287          addMonitorAttribute(attrs,
1288               "total-critical-state-duration",
1289               INFO_GAUGE_DISPNAME_TOTAL_CRITICAL_DURATION_STRING.get(),
1290               INFO_GAUGE_DESC_TOTAL_CRITICAL_DURATION_STRING.get(),
1291               totalCriticalStateDurationString);
1292        }
1293    
1294        if (totalCriticalStateDurationMillis != null)
1295        {
1296          addMonitorAttribute(attrs,
1297               "total-critical-state-duration-millis",
1298               INFO_GAUGE_DISPNAME_TOTAL_CRITICAL_DURATION_MILLIS.get(),
1299               INFO_GAUGE_DESC_TOTAL_CRITICAL_DURATION_MILLIS.get(),
1300               totalCriticalStateDurationMillis);
1301        }
1302    
1303        return Collections.unmodifiableMap(attrs);
1304      }
1305    }