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.ArrayList; 026 import java.util.Collections; 027 import java.util.LinkedHashMap; 028 import java.util.List; 029 import java.util.Map; 030 import java.util.StringTokenizer; 031 032 import com.unboundid.ldap.sdk.Entry; 033 import com.unboundid.util.Debug; 034 import com.unboundid.util.NotMutable; 035 import com.unboundid.util.ThreadSafety; 036 import com.unboundid.util.ThreadSafetyLevel; 037 038 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 039 040 041 042 /** 043 * <BLOCKQUOTE> 044 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 045 * LDAP SDK for Java. It is not available for use in applications that 046 * include only the Standard Edition of the LDAP SDK, and is not supported for 047 * use in conjunction with non-UnboundID products. 048 * </BLOCKQUOTE> 049 * This class defines a numeric gauge monitor entry, which obtains its 050 * information from a numeric value in a monitor entry. 051 */ 052 @NotMutable() 053 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 054 public final class NumericGaugeMonitorEntry 055 extends GaugeMonitorEntry 056 { 057 /** 058 * The structural object class used in gauge monitor entries. 059 */ 060 static final String NUMERIC_GAUGE_MONITOR_OC = 061 "ds-numeric-gauge-monitor-entry"; 062 063 064 065 /** 066 * The serial version UID for this serializable class. 067 */ 068 private static final long serialVersionUID = 2049893927290436280L; 069 070 071 072 // The current value for the gauge. 073 private final Double currentValue; 074 075 // The maximum value observed for the gauge. 076 private final Double maximumValue; 077 078 // The minimum value observed for the gauge. 079 private final Double minimumValue; 080 081 // The current value for the gauge. 082 private final Double previousValue; 083 084 // The set of observed values for the gauge. 085 private final List<Double> observedValues; 086 087 088 089 /** 090 * Creates a new numeric gauge monitor entry from the provided entry. 091 * 092 * @param entry The entry to be parsed as a numeric gauge monitor entry. It 093 * must not be {@code null}. 094 */ 095 public NumericGaugeMonitorEntry(final Entry entry) 096 { 097 super(entry); 098 099 currentValue = getDouble("value"); 100 previousValue = getDouble("previous-value"); 101 minimumValue = getDouble("value-minimum"); 102 maximumValue = getDouble("value-maximum"); 103 104 final String observedStr = getString("observed-values"); 105 if ((observedStr == null) || (observedStr.length() == 0)) 106 { 107 observedValues = Collections.emptyList(); 108 } 109 else 110 { 111 final ArrayList<Double> values = new ArrayList<Double>(10); 112 try 113 { 114 final StringTokenizer tokenizer = new StringTokenizer(observedStr, ","); 115 while (tokenizer.hasMoreTokens()) 116 { 117 values.add(Double.parseDouble(tokenizer.nextToken())); 118 } 119 } 120 catch (final Exception e) 121 { 122 Debug.debugException(e); 123 values.clear(); 124 } 125 126 observedValues = Collections.unmodifiableList(values); 127 } 128 } 129 130 131 132 /** 133 * Retrieves the current value for the gauge, if available. 134 * 135 * @return The current value for the gauge, or {@code null} if it was not 136 * included in the monitor entry. 137 */ 138 public Double getCurrentValue() 139 { 140 return currentValue; 141 } 142 143 144 145 /** 146 * Retrieves the previous value for the gauge, if available. 147 * 148 * @return The previous value for the gauge, or {@code null} if it was not 149 * included in the monitor entry. 150 */ 151 public Double getPreviousValue() 152 { 153 return previousValue; 154 } 155 156 157 158 /** 159 * Retrieves the minimum value observed for the gauge, if available. 160 * 161 * @return The minimum value observed for the gauge, or {@code null} if it 162 * was not included in the monitor entry. 163 */ 164 public Double getMinimumValue() 165 { 166 return minimumValue; 167 } 168 169 170 171 /** 172 * Retrieves the maximum value observed for the gauge, if available. 173 * 174 * @return The maximum value observed for the gauge, or {@code null} if it 175 * was not included in the monitor entry. 176 */ 177 public Double getMaximumValue() 178 { 179 return maximumValue; 180 } 181 182 183 184 /** 185 * Retrieves the set of observed values for the gauge, if available. 186 * 187 * @return The set of observed values for the gauge, or {@code null} if it 188 * was not included in the monitor entry. 189 */ 190 public List<Double> getObservedValues() 191 { 192 return observedValues; 193 } 194 195 196 197 /** 198 * {@inheritDoc} 199 */ 200 @Override() 201 public String getMonitorDisplayName() 202 { 203 return INFO_NUMERIC_GAUGE_MONITOR_DISPNAME.get(); 204 } 205 206 207 208 /** 209 * {@inheritDoc} 210 */ 211 @Override() 212 public String getMonitorDescription() 213 { 214 return INFO_NUMERIC_GAUGE_MONITOR_DESC.get(); 215 } 216 217 218 219 /** 220 * {@inheritDoc} 221 */ 222 @Override() 223 public Map<String,MonitorAttribute> getMonitorAttributes() 224 { 225 final Map<String,MonitorAttribute> superAttributes = 226 super.getMonitorAttributes(); 227 228 final LinkedHashMap<String,MonitorAttribute> attrs = 229 new LinkedHashMap<String,MonitorAttribute>(superAttributes.size() + 5); 230 attrs.putAll(superAttributes); 231 232 if (currentValue != null) 233 { 234 addMonitorAttribute(attrs, 235 "value", 236 INFO_NUMERIC_GAUGE_DISPNAME_CURRENT_VALUE.get(), 237 INFO_NUMERIC_GAUGE_DESC_CURRENT_VALUE.get(), 238 currentValue); 239 } 240 241 if (previousValue != null) 242 { 243 addMonitorAttribute(attrs, 244 "previous-value", 245 INFO_NUMERIC_GAUGE_DISPNAME_PREVIOUS_VALUE.get(), 246 INFO_NUMERIC_GAUGE_DESC_PREVIOUS_VALUE.get(), 247 previousValue); 248 } 249 250 if (minimumValue != null) 251 { 252 addMonitorAttribute(attrs, 253 "value-minimum", 254 INFO_NUMERIC_GAUGE_DISPNAME_MINIMUM_VALUE.get(), 255 INFO_NUMERIC_GAUGE_DESC_MINIMUM_VALUE.get(), 256 minimumValue); 257 } 258 259 if (maximumValue != null) 260 { 261 addMonitorAttribute(attrs, 262 "value-maximum", 263 INFO_NUMERIC_GAUGE_DISPNAME_MAXIMUM_VALUE.get(), 264 INFO_NUMERIC_GAUGE_DESC_MAXIMUM_VALUE.get(), 265 maximumValue); 266 } 267 268 if (! observedValues.isEmpty()) 269 { 270 final Double[] values = new Double[observedValues.size()]; 271 observedValues.toArray(values); 272 273 attrs.put("observed-values", 274 new MonitorAttribute("observed-values", 275 INFO_NUMERIC_GAUGE_DISPNAME_OBSERVED_VALUES.get(), 276 INFO_NUMERIC_GAUGE_DESC_OBSERVED_VALUES.get(), 277 values)); 278 } 279 280 return Collections.unmodifiableMap(attrs); 281 } 282 }