001/*
002 * Copyright 2009-2020 Ping Identity Corporation
003 * All Rights Reserved.
004 */
005/*
006 * Copyright 2009-2020 Ping Identity Corporation
007 *
008 * Licensed under the Apache License, Version 2.0 (the "License");
009 * you may not use this file except in compliance with the License.
010 * You may obtain a copy of the License at
011 *
012 *    http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing, software
015 * distributed under the License is distributed on an "AS IS" BASIS,
016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017 * See the License for the specific language governing permissions and
018 * limitations under the License.
019 */
020/*
021 * Copyright (C) 2015-2020 Ping Identity Corporation
022 *
023 * This program is free software; you can redistribute it and/or modify
024 * it under the terms of the GNU General Public License (GPLv2 only)
025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
026 * as published by the Free Software Foundation.
027 *
028 * This program is distributed in the hope that it will be useful,
029 * but WITHOUT ANY WARRANTY; without even the implied warranty of
030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
031 * GNU General Public License for more details.
032 *
033 * You should have received a copy of the GNU General Public License
034 * along with this program; if not, see <http://www.gnu.org/licenses>.
035 */
036package com.unboundid.ldap.sdk.unboundidds.monitors;
037
038
039
040import java.util.Collections;
041import java.util.Date;
042import java.util.LinkedHashMap;
043import java.util.List;
044import java.util.Map;
045
046import com.unboundid.ldap.sdk.Entry;
047import com.unboundid.util.NotMutable;
048import com.unboundid.util.StaticUtils;
049import com.unboundid.util.ThreadSafety;
050import com.unboundid.util.ThreadSafetyLevel;
051
052import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
053
054
055
056/**
057 * This class defines a monitor entry that provides general information about
058 * an LDAP external server used by the Directory Proxy Server.
059 * <BR>
060 * <BLOCKQUOTE>
061 *   <B>NOTE:</B>  This class, and other classes within the
062 *   {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
063 *   supported for use against Ping Identity, UnboundID, and
064 *   Nokia/Alcatel-Lucent 8661 server products.  These classes provide support
065 *   for proprietary functionality or for external specifications that are not
066 *   considered stable or mature enough to be guaranteed to work in an
067 *   interoperable way with other types of LDAP servers.
068 * </BLOCKQUOTE>
069 * <BR>
070 * Information that it may make available includes:
071 * <UL>
072 *   <LI>The address, port, and security mechanism used to communicate with the
073 *       server.</LI>
074 *   <LI>The DN of the configuration entry for the load-balancing algorithm that
075 *       is using the LDAP external server object.</LI>
076 *   <LI>Information about the health of the LDAP external server.</LI>
077 *   <LI>The number of attempted, successful, and failed operations processed
078 *       using the LDAP external server.</LI>
079 * </UL>
080 * The server should present an LDAP external server monitor entry for each
081 * server used by each load-balancing algorithm.  These entries can be retrieved
082 * using the {@link MonitorManager#getLDAPExternalServerMonitorEntries} method.
083 * These entries provide specific methods for accessing this information.
084 * Alternately, the information may be accessed using the generic API.  See the
085 * {@link MonitorManager} class documentation for an example that demonstrates
086 * the use of the generic API for accessing monitor data.
087 */
088@NotMutable()
089@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
090public final class LDAPExternalServerMonitorEntry
091       extends MonitorEntry
092{
093  /**
094   * The structural object class used in LDAP external server monitor entries.
095   */
096  protected static final String LDAP_EXTERNAL_SERVER_MONITOR_OC =
097       "ds-ldap-external-server-monitor-entry";
098
099
100
101  /**
102   * The name of the attribute used to provide the number of add operations
103   * attempted in the backend server.
104   */
105  private static final String ATTR_ADD_ATTEMPTS = "add-attempts";
106
107
108
109  /**
110   * The name of the attribute used to provide the number of add operations
111   * that failed.
112   */
113  private static final String ATTR_ADD_FAILURES = "add-failures";
114
115
116
117  /**
118   * The name of the attribute used to provide the number of add operations
119   * completed successfully.
120   */
121  private static final String ATTR_ADD_SUCCESSES = "add-successes";
122
123
124
125  /**
126   * The name of the attribute used to provide the number of bind operations
127   * attempted in the backend server.
128   */
129  private static final String ATTR_BIND_ATTEMPTS = "bind-attempts";
130
131
132
133  /**
134   * The name of the attribute used to provide the number of bind operations
135   * that failed.
136   */
137  private static final String ATTR_BIND_FAILURES = "bind-failures";
138
139
140
141  /**
142   * The name of the attribute used to provide the number of bind operations
143   * completed successfully.
144   */
145  private static final String ATTR_BIND_SUCCESSES = "bind-successes";
146
147
148
149  /**
150   * The name of the attribute used to provide the communication security
151   * mechanism.
152   */
153  private static final String ATTR_COMMUNICATION_SECURITY =
154       "communication-security";
155
156
157
158  /**
159   * The name of the attribute used to provide the number of compare operations
160   * attempted in the backend server.
161   */
162  private static final String ATTR_COMPARE_ATTEMPTS = "compare-attempts";
163
164
165
166  /**
167   * The name of the attribute used to provide the number of compare operations
168   * that failed.
169   */
170  private static final String ATTR_COMPARE_FAILURES = "compare-failures";
171
172
173
174  /**
175   * The name of the attribute used to provide the number of compare operations
176   * completed successfully.
177   */
178  private static final String ATTR_COMPARE_SUCCESSES = "compare-successes";
179
180
181
182  /**
183   * The name of the attribute used to provide the number of delete operations
184   * attempted in the backend server.
185   */
186  private static final String ATTR_DELETE_ATTEMPTS = "delete-attempts";
187
188
189
190  /**
191   * The name of the attribute used to provide the number of delete operations
192   * that failed.
193   */
194  private static final String ATTR_DELETE_FAILURES = "delete-failures";
195
196
197
198  /**
199   * The name of the attribute used to provide the number of delete operations
200   * completed successfully.
201   */
202  private static final String ATTR_DELETE_SUCCESSES = "delete-successes";
203
204
205
206  /**
207   * The name of the attribute used to provide health check messages.
208   */
209  private static final String ATTR_HEALTH_CHECK_MESSAGE =
210       "health-check-message";
211
212
213
214  /**
215   * The name of the attribute used to provide the health check state.
216   */
217  private static final String ATTR_HEALTH_CHECK_STATE = "health-check-state";
218
219
220
221  /**
222   * The name of the attribute used to provide the health check score.
223   */
224  private static final String ATTR_HEALTH_CHECK_SCORE = "health-check-score";
225
226
227
228  /**
229   * The name of the attribute used to provide the time the health check
230   * information was last updated.
231   */
232  private static final String ATTR_HEALTH_CHECK_UPDATE_TIME =
233       "health-check-update-time";
234
235
236
237  /**
238   * The name of the attribute used to provide the DN of the load-balancing
239   * algorithm configuration entry.
240   */
241  private static final String ATTR_LOAD_BALANCING_ALGORITHM_DN =
242       "load-balancing-algorithm";
243
244
245
246  /**
247   * The name of the attribute used to provide the number of modify operations
248   * attempted in the backend server.
249   */
250  private static final String ATTR_MODIFY_ATTEMPTS = "modify-attempts";
251
252
253
254  /**
255   * The name of the attribute used to provide the number of modify operations
256   * that failed.
257   */
258  private static final String ATTR_MODIFY_FAILURES = "modify-failures";
259
260
261
262  /**
263   * The name of the attribute used to provide the number of modify operations
264   * completed successfully.
265   */
266  private static final String ATTR_MODIFY_SUCCESSES = "modify-successes";
267
268
269
270  /**
271   * The name of the attribute used to provide the number of modify DN
272   * operations attempted in the backend server.
273   */
274  private static final String ATTR_MODIFY_DN_ATTEMPTS = "modify-dn-attempts";
275
276
277
278  /**
279   * The name of the attribute used to provide the number of modify DN
280   * operations that failed.
281   */
282  private static final String ATTR_MODIFY_DN_FAILURES = "modify-dn-failures";
283
284
285
286  /**
287   * The name of the attribute used to provide the number of modify DN
288   * operations completed successfully.
289   */
290  private static final String ATTR_MODIFY_DN_SUCCESSES = "modify-dn-successes";
291
292
293
294  /**
295   * The name of the attribute used to provide the number of search operations
296   * attempted in the backend server.
297   */
298  private static final String ATTR_SEARCH_ATTEMPTS = "search-attempts";
299
300
301
302  /**
303   * The name of the attribute used to provide the number of search operations
304   * that failed.
305   */
306  private static final String ATTR_SEARCH_FAILURES = "search-failures";
307
308
309
310  /**
311   * The name of the attribute used to provide the number of search operations
312   * completed successfully.
313   */
314  private static final String ATTR_SEARCH_SUCCESSES = "search-successes";
315
316
317
318  /**
319   * The name of the attribute used to provide the server address.
320   */
321  private static final String ATTR_SERVER_ADDRESS = "server-address";
322
323
324
325  /**
326   * The name of the attribute used to provide the server port.
327   */
328  private static final String ATTR_SERVER_PORT = "server-port";
329
330
331
332  /**
333   * The prefix for attributes providing information from a connection pool used
334   * only for bind operations.
335   */
336  private static final String ATTR_PREFIX_BIND_POOL = "bind-";
337
338
339
340  /**
341   * The prefix for attributes providing information from a connection pool used
342   * for all types of operations.
343   */
344  private static final String ATTR_PREFIX_COMMON_POOL = "common-";
345
346
347
348  /**
349   * The prefix for attributes providing information from a connection pool used
350   * only for non-bind operations.
351   */
352  private static final String ATTR_PREFIX_NONBIND_POOL = "non-bind-";
353
354
355
356  /**
357   * The suffix for the attribute used to provide the number of available
358   * connections from a pool.
359   */
360  private static final String ATTR_SUFFIX_AVAILABLE_CONNS =
361       "pool-available-connections";
362
363
364
365  /**
366   * The suffix for the attribute used to provide the number of connections
367   * closed as defunct.
368   */
369  private static final String ATTR_SUFFIX_CLOSED_DEFUNCT =
370       "pool-num-closed-defunct";
371
372
373
374  /**
375   * The suffix for the attribute used to provide the number of connections
376   * closed as expired.
377   */
378  private static final String ATTR_SUFFIX_CLOSED_EXPIRED =
379       "pool-num-closed-expired";
380
381
382
383  /**
384   * The suffix for the attribute used to provide the number of connections
385   * closed as unneeded.
386   */
387  private static final String ATTR_SUFFIX_CLOSED_UNNEEDED =
388       "pool-num-closed-unneeded";
389
390
391
392  /**
393   * The suffix for the attribute used to provide the number of failed
394   * checkouts.
395   */
396  private static final String ATTR_SUFFIX_FAILED_CHECKOUTS =
397       "pool-num-failed-checkouts";
398
399
400
401  /**
402   * The suffix for the attribute used to provide the number of failed
403   * connection attempts.
404   */
405  private static final String ATTR_SUFFIX_FAILED_CONNECTS =
406       "pool-num-failed-connection-attempts";
407
408
409
410  /**
411   * The suffix for the attribute used to provide the maximum number of
412   * available connections from a pool.
413   */
414  private static final String ATTR_SUFFIX_MAX_AVAILABLE_CONNS =
415       "pool-max-available-connections";
416
417
418
419  /**
420   * The suffix for the attribute used to provide the number of connections
421   * released as valid back to the pool.
422   */
423  private static final String ATTR_SUFFIX_RELEASED_VALID =
424       "pool-num-released-valid";
425
426
427
428  /**
429   * The suffix for the attribute used to provide the number of successful
430   * checkouts.
431   */
432  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS =
433       "pool-num-successful-checkouts";
434
435
436
437  /**
438   * The suffix for the attribute used to provide the number of successful
439   * checkouts after waiting for a connection to become available.
440   */
441  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING =
442       "pool-num-successful-checkouts-after-waiting";
443
444
445
446  /**
447   * The suffix for the attribute used to provide the number of successful
448   * checkouts after creating a new connection.
449   */
450  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN =
451       "pool-num-successful-checkouts-new-connection";
452
453
454
455  /**
456   * The suffix for the attribute used to provide the number of successful
457   * checkouts without waiting.
458   */
459  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING =
460       "pool-num-successful-checkouts-without-waiting";
461
462
463
464  /**
465   * The suffix for the attribute used to provide the number of successful
466   * connection attempts.
467   */
468  private static final String ATTR_SUFFIX_SUCCESSFUL_CONNECTS =
469       "pool-num-successful-connection-attempts";
470
471
472
473  /**
474   * The serial version UID for this serializable class.
475   */
476  private static final long serialVersionUID = 6054649631882735072L;
477
478
479
480  // The time the health check information was last updated.
481  private final Date healthCheckUpdateTime;
482
483  // The health check state for the server.
484  private final HealthCheckState healthCheckState;
485
486  // The list of health check messages.
487  private final List<String> healthCheckMessages;
488
489  // The number of add operations attempted.
490  private final Long addAttempts;
491
492  // The number of failed add operations.
493  private final Long addFailures;
494
495  // The number of successful add operations.
496  private final Long addSuccesses;
497
498  // The number of bind operations attempted.
499  private final Long bindAttempts;
500
501  // The number of failed bind operations.
502  private final Long bindFailures;
503
504  // The number of available connections in the bind pool.
505  private final Long bindPoolAvailableConnections;
506
507  // The maximum number of available connections in the bind pool.
508  private final Long bindPoolMaxAvailableConnections;
509
510  // The number of connections in the bind pool that have been closed as
511  // defunct.
512  private final Long bindPoolNumClosedDefunct;
513
514  // The number of connections in the bind pool that have been closed as
515  // expired.
516  private final Long bindPoolNumClosedExpired;
517
518  // The number of connections in the bind pool that have been closed as
519  // unneeded.
520  private final Long bindPoolNumClosedUnneeded;
521
522  // The number of available failed checkouts in the bind pool.
523  private final Long bindPoolNumFailedCheckouts;
524
525  // The number of available failed connection attempts in the bind pool.
526  private final Long bindPoolNumFailedConnectionAttempts;
527
528  // The total number of connections released as valid back to the bind pool.
529  private final Long bindPoolNumReleasedValid;
530
531  // The total number of successful checkouts from the bind pool.
532  private final Long bindPoolNumSuccessfulCheckouts;
533
534  // The total number of successful checkouts from the bind pool after waiting
535  // for a connection to become available.
536  private final Long bindPoolNumSuccessfulCheckoutsAfterWaiting;
537
538  // The total number of successful checkouts from the bind pool after creating
539  // a new connection.
540  private final Long bindPoolNumSuccessfulCheckoutsNewConnection;
541
542  // The total number of successful checkouts from the bind pool without waiting
543  // for a connection to become available.
544  private final Long bindPoolNumSuccessfulCheckoutsWithoutWaiting;
545
546  // The number of successful connection attempts in the bind pool.
547  private final Long bindPoolNumSuccessfulConnectionAttempts;
548
549  // The number of successful bind operations.
550  private final Long bindSuccesses;
551
552  // The number of available connections in the common pool.
553  private final Long commonPoolAvailableConnections;
554
555  // The maximum number of available connections in the common pool.
556  private final Long commonPoolMaxAvailableConnections;
557
558  // The number of connections in the common pool that have been closed as
559  // defunct.
560  private final Long commonPoolNumClosedDefunct;
561
562  // The number of connections in the common pool that have been closed as
563  // expired.
564  private final Long commonPoolNumClosedExpired;
565
566  // The number of connections in the common pool that have been closed as
567  // unneeded.
568  private final Long commonPoolNumClosedUnneeded;
569
570  // The number of available failed checkouts in the common pool.
571  private final Long commonPoolNumFailedCheckouts;
572
573  // The number of available failed connection attempts in the common pool.
574  private final Long commonPoolNumFailedConnectionAttempts;
575
576  // The total number of connections released as valid back to the common pool.
577  private final Long commonPoolNumReleasedValid;
578
579  // The total number of successful checkouts from the common pool.
580  private final Long commonPoolNumSuccessfulCheckouts;
581
582  // The total number of successful checkouts from the common pool after waiting
583  // for a connection to become available.
584  private final Long commonPoolNumSuccessfulCheckoutsAfterWaiting;
585
586  // The total number of successful checkouts from the common pool after
587  // creating a new connection.
588  private final Long commonPoolNumSuccessfulCheckoutsNewConnection;
589
590  // The total number of successful checkouts from the common pool without
591  // waiting for a connection to become available.
592  private final Long commonPoolNumSuccessfulCheckoutsWithoutWaiting;
593
594  // The number of successful connection attempts in the common pool.
595  private final Long commonPoolNumSuccessfulConnectionAttempts;
596
597  // The number of compare operations attempted.
598  private final Long compareAttempts;
599
600  // The number of failed compare operations.
601  private final Long compareFailures;
602
603  // The number of successful compare operations.
604  private final Long compareSuccesses;
605
606  // The number of delete operations attempted.
607  private final Long deleteAttempts;
608
609  // The number of failed delete operations.
610  private final Long deleteFailures;
611
612  // The number of successful delete operations.
613  private final Long deleteSuccesses;
614
615  // The health check score for the server.
616  private final Long healthCheckScore;
617
618  // The number of modify operations attempted.
619  private final Long modifyAttempts;
620
621  // The number of failed modify operations.
622  private final Long modifyFailures;
623
624  // The number of successful modify operations.
625  private final Long modifySuccesses;
626
627  // The number of modify DN operations attempted.
628  private final Long modifyDNAttempts;
629
630  // The number of failed modify DN operations.
631  private final Long modifyDNFailures;
632
633  // The number of successful modify DN operations.
634  private final Long modifyDNSuccesses;
635
636  // The number of available connections in the non-bind pool.
637  private final Long nonBindPoolAvailableConnections;
638
639  // The maximum number of available connections in the non-bind pool.
640  private final Long nonBindPoolMaxAvailableConnections;
641
642  // The number of connections in the non-bind pool that have been closed as
643  // defunct.
644  private final Long nonBindPoolNumClosedDefunct;
645
646  // The number of connections in the non-bind pool that have been closed as
647  // expired.
648  private final Long nonBindPoolNumClosedExpired;
649
650  // The number of connections in the non-bind pool that have been closed as
651  // unneeded.
652  private final Long nonBindPoolNumClosedUnneeded;
653
654  // The number of available failed checkouts in the non-bind pool.
655  private final Long nonBindPoolNumFailedCheckouts;
656
657  // The number of available failed connection attempts in the non-bind pool.
658  private final Long nonBindPoolNumFailedConnectionAttempts;
659
660  // The total number of connections released as valid back to the non-bind
661  // pool.
662  private final Long nonBindPoolNumReleasedValid;
663
664  // The total number of successful checkouts from the non-bind pool.
665  private final Long nonBindPoolNumSuccessfulCheckouts;
666
667  // The total number of successful checkouts from the non-bind pool after
668  // waiting for a connection to become available.
669  private final Long nonBindPoolNumSuccessfulCheckoutsAfterWaiting;
670
671  // The total number of successful checkouts from the non-bind pool after
672  // creating a new connection.
673  private final Long nonBindPoolNumSuccessfulCheckoutsNewConnection;
674
675  // The total number of successful checkouts from the non-bind pool without
676  // waiting for a connection to become available.
677  private final Long nonBindPoolNumSuccessfulCheckoutsWithoutWaiting;
678
679  // The number of successful connection attempts in the non-bind pool.
680  private final Long nonBindPoolNumSuccessfulConnectionAttempts;
681
682  // The number of search operations attempted.
683  private final Long searchAttempts;
684
685  // The number of failed search operations.
686  private final Long searchFailures;
687
688  // The number of successful search operations.
689  private final Long searchSuccesses;
690
691  // The port of the server.
692  private final Long serverPort;
693
694  // The communication security mechanism used by the server.
695  private final String communicationSecurity;
696
697  // The DN of the load-balancing algorithm.
698  private final String loadBalancingAlgorithmDN;
699
700  // The address of the server.
701  private final String serverAddress;
702
703
704
705  /**
706   * Creates a new LDAP external server monitor entry from the provided entry.
707   *
708   * @param  entry  The entry to be parsed as an LDAP external server monitor
709   *                entry.  It must not be {@code null}.
710   */
711  public LDAPExternalServerMonitorEntry(final Entry entry)
712  {
713    super(entry);
714
715    serverAddress            = getString(ATTR_SERVER_ADDRESS);
716    serverPort               = getLong(ATTR_SERVER_PORT);
717    communicationSecurity    = getString(ATTR_COMMUNICATION_SECURITY);
718    loadBalancingAlgorithmDN = getString(ATTR_LOAD_BALANCING_ALGORITHM_DN);
719    healthCheckScore         = getLong(ATTR_HEALTH_CHECK_SCORE);
720    healthCheckMessages      = getStrings(ATTR_HEALTH_CHECK_MESSAGE);
721    healthCheckUpdateTime    = getDate(ATTR_HEALTH_CHECK_UPDATE_TIME);
722    addAttempts              = getLong(ATTR_ADD_ATTEMPTS);
723    addFailures              = getLong(ATTR_ADD_FAILURES);
724    addSuccesses             = getLong(ATTR_ADD_SUCCESSES);
725    bindAttempts             = getLong(ATTR_BIND_ATTEMPTS);
726    bindFailures             = getLong(ATTR_BIND_FAILURES);
727    bindSuccesses            = getLong(ATTR_BIND_SUCCESSES);
728    compareAttempts          = getLong(ATTR_COMPARE_ATTEMPTS);
729    compareFailures          = getLong(ATTR_COMPARE_FAILURES);
730    compareSuccesses         = getLong(ATTR_COMPARE_SUCCESSES);
731    deleteAttempts           = getLong(ATTR_DELETE_ATTEMPTS);
732    deleteFailures           = getLong(ATTR_DELETE_FAILURES);
733    deleteSuccesses          = getLong(ATTR_DELETE_SUCCESSES);
734    modifyAttempts           = getLong(ATTR_MODIFY_ATTEMPTS);
735    modifyFailures           = getLong(ATTR_MODIFY_FAILURES);
736    modifySuccesses          = getLong(ATTR_MODIFY_SUCCESSES);
737    modifyDNAttempts         = getLong(ATTR_MODIFY_DN_ATTEMPTS);
738    modifyDNFailures         = getLong(ATTR_MODIFY_DN_FAILURES);
739    modifyDNSuccesses        = getLong(ATTR_MODIFY_DN_SUCCESSES);
740    searchAttempts           = getLong(ATTR_SEARCH_ATTEMPTS);
741    searchFailures           = getLong(ATTR_SEARCH_FAILURES);
742    searchSuccesses          = getLong(ATTR_SEARCH_SUCCESSES);
743
744    bindPoolAvailableConnections = getLong(ATTR_PREFIX_BIND_POOL +
745         ATTR_SUFFIX_AVAILABLE_CONNS);
746    bindPoolMaxAvailableConnections = getLong(ATTR_PREFIX_BIND_POOL +
747         ATTR_SUFFIX_MAX_AVAILABLE_CONNS);
748    bindPoolNumSuccessfulConnectionAttempts = getLong(ATTR_PREFIX_BIND_POOL +
749         ATTR_SUFFIX_SUCCESSFUL_CONNECTS);
750    bindPoolNumFailedConnectionAttempts = getLong(ATTR_PREFIX_BIND_POOL +
751         ATTR_SUFFIX_FAILED_CONNECTS);
752    bindPoolNumClosedDefunct = getLong(ATTR_PREFIX_BIND_POOL +
753         ATTR_SUFFIX_CLOSED_DEFUNCT);
754    bindPoolNumClosedExpired = getLong(ATTR_PREFIX_BIND_POOL +
755         ATTR_SUFFIX_CLOSED_EXPIRED);
756    bindPoolNumClosedUnneeded = getLong(ATTR_PREFIX_BIND_POOL +
757         ATTR_SUFFIX_CLOSED_UNNEEDED);
758    bindPoolNumSuccessfulCheckouts = getLong(ATTR_PREFIX_BIND_POOL +
759         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS);
760    bindPoolNumSuccessfulCheckoutsWithoutWaiting = getLong(
761         ATTR_PREFIX_BIND_POOL +
762         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING);
763    bindPoolNumSuccessfulCheckoutsAfterWaiting = getLong(ATTR_PREFIX_BIND_POOL +
764         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING);
765    bindPoolNumSuccessfulCheckoutsNewConnection = getLong(
766         ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN);
767    bindPoolNumFailedCheckouts = getLong(ATTR_PREFIX_BIND_POOL +
768         ATTR_SUFFIX_FAILED_CHECKOUTS);
769    bindPoolNumReleasedValid = getLong(ATTR_PREFIX_BIND_POOL +
770         ATTR_SUFFIX_RELEASED_VALID);
771
772    commonPoolAvailableConnections = getLong(ATTR_PREFIX_COMMON_POOL +
773         ATTR_SUFFIX_AVAILABLE_CONNS);
774    commonPoolMaxAvailableConnections = getLong(ATTR_PREFIX_COMMON_POOL +
775         ATTR_SUFFIX_MAX_AVAILABLE_CONNS);
776    commonPoolNumSuccessfulConnectionAttempts = getLong(
777         ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS);
778    commonPoolNumFailedConnectionAttempts = getLong(ATTR_PREFIX_COMMON_POOL +
779         ATTR_SUFFIX_FAILED_CONNECTS);
780    commonPoolNumClosedDefunct = getLong(ATTR_PREFIX_COMMON_POOL +
781         ATTR_SUFFIX_CLOSED_DEFUNCT);
782    commonPoolNumClosedExpired = getLong(ATTR_PREFIX_COMMON_POOL +
783         ATTR_SUFFIX_CLOSED_EXPIRED);
784    commonPoolNumClosedUnneeded = getLong(ATTR_PREFIX_COMMON_POOL +
785         ATTR_SUFFIX_CLOSED_UNNEEDED);
786    commonPoolNumSuccessfulCheckouts = getLong(ATTR_PREFIX_COMMON_POOL +
787         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS);
788    commonPoolNumSuccessfulCheckoutsWithoutWaiting = getLong(
789         ATTR_PREFIX_COMMON_POOL +
790         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING);
791    commonPoolNumSuccessfulCheckoutsAfterWaiting = getLong(
792         ATTR_PREFIX_COMMON_POOL +
793         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING);
794    commonPoolNumSuccessfulCheckoutsNewConnection = getLong(
795         ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN);
796    commonPoolNumFailedCheckouts = getLong(ATTR_PREFIX_COMMON_POOL +
797         ATTR_SUFFIX_FAILED_CHECKOUTS);
798    commonPoolNumReleasedValid = getLong(ATTR_PREFIX_COMMON_POOL +
799         ATTR_SUFFIX_RELEASED_VALID);
800
801    nonBindPoolAvailableConnections = getLong(ATTR_PREFIX_NONBIND_POOL +
802         ATTR_SUFFIX_AVAILABLE_CONNS);
803    nonBindPoolMaxAvailableConnections = getLong(ATTR_PREFIX_NONBIND_POOL +
804         ATTR_SUFFIX_MAX_AVAILABLE_CONNS);
805    nonBindPoolNumSuccessfulConnectionAttempts = getLong(
806         ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS);
807    nonBindPoolNumFailedConnectionAttempts = getLong(ATTR_PREFIX_NONBIND_POOL +
808         ATTR_SUFFIX_FAILED_CONNECTS);
809    nonBindPoolNumClosedDefunct = getLong(ATTR_PREFIX_NONBIND_POOL +
810         ATTR_SUFFIX_CLOSED_DEFUNCT);
811    nonBindPoolNumClosedExpired = getLong(ATTR_PREFIX_NONBIND_POOL +
812         ATTR_SUFFIX_CLOSED_EXPIRED);
813    nonBindPoolNumClosedUnneeded = getLong(ATTR_PREFIX_NONBIND_POOL +
814         ATTR_SUFFIX_CLOSED_UNNEEDED);
815    nonBindPoolNumSuccessfulCheckouts = getLong(ATTR_PREFIX_NONBIND_POOL +
816         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS);
817    nonBindPoolNumSuccessfulCheckoutsWithoutWaiting = getLong(
818         ATTR_PREFIX_NONBIND_POOL +
819         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING);
820    nonBindPoolNumSuccessfulCheckoutsAfterWaiting = getLong(
821         ATTR_PREFIX_NONBIND_POOL +
822         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING);
823    nonBindPoolNumSuccessfulCheckoutsNewConnection = getLong(
824         ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN);
825    nonBindPoolNumFailedCheckouts = getLong(ATTR_PREFIX_NONBIND_POOL +
826         ATTR_SUFFIX_FAILED_CHECKOUTS);
827    nonBindPoolNumReleasedValid = getLong(ATTR_PREFIX_NONBIND_POOL +
828         ATTR_SUFFIX_RELEASED_VALID);
829
830    final String hcStateStr = getString(ATTR_HEALTH_CHECK_STATE);
831    if (hcStateStr == null)
832    {
833      healthCheckState = null;
834    }
835    else
836    {
837      healthCheckState = HealthCheckState.forName(hcStateStr);
838    }
839  }
840
841
842
843  /**
844   * Retrieves the address of the LDAP external server.
845   *
846   * @return  The address of the LDAP external server, or {@code null} if it was
847   *          not included in the monitor entry.
848   */
849  public String getServerAddress()
850  {
851    return serverAddress;
852  }
853
854
855
856  /**
857   * Retrieves the port of the LDAP external server.
858   *
859   * @return  The port of the LDAP external server, or {@code null} if it was
860   *          not included in the monitor entry.
861   */
862  public Long getServerPort()
863  {
864    return serverPort;
865  }
866
867
868
869  /**
870   * Retrieves the communication security mechanism used when communicating with
871   * the external server.
872   *
873   * @return  The communication security mechanism used when communicating with
874   *          the external server, or {@code null} if it was not included in the
875   *          monitor entry.
876   */
877  public String getCommunicationSecurity()
878  {
879    return communicationSecurity;
880  }
881
882
883
884  /**
885   * Retrieves the DN of the configuration entry for the load-balancing
886   * algorithm that uses the LDAP external server.
887   *
888   * @return  The DN of the configuration entry for the load-balancing algorithm
889   *          that uses the LDAP external server, or {@code null} if it was not
890   *          included in the monitor entry.
891   */
892  public String getLoadBalancingAlgorithmDN()
893  {
894    return loadBalancingAlgorithmDN;
895  }
896
897
898
899  /**
900   * Retrieves the health check state for the LDAP external server.
901   *
902   * @return  The health check state for the LDAP external server, or
903   *          {@code null} if it was not included in the monitor entry.
904   */
905  public HealthCheckState getHealthCheckState()
906  {
907    return healthCheckState;
908  }
909
910
911
912  /**
913   * Retrieves the health check score for the LDAP external server.
914   *
915   * @return  The health check score for the LDAP external server, or
916   *          {@code null} if it was not included in the monitor entry.
917   */
918  public Long getHealthCheckScore()
919  {
920    return healthCheckScore;
921  }
922
923
924
925  /**
926   * Retrieves the list of health check messages for the LDAP external server.
927   *
928   * @return  The list of health check messages for the LDAP external server, or
929   *          an empty list if it was not included in the monitor entry.
930   */
931  public List<String> getHealthCheckMessages()
932  {
933    return healthCheckMessages;
934  }
935
936
937
938  /**
939   * Retrieves the time the health check information was last updated for the
940   * LDAP external server.
941   *
942   * @return  The time the health check information was last updated for the
943   *          LDAP external server, or {@code null} if it was not included in
944   *          the monitor entry.
945   */
946  public Date getHealthCheckUpdateTime()
947  {
948    return healthCheckUpdateTime;
949  }
950
951
952
953  /**
954   * Retrieves the total number of add operations attempted against the LDAP
955   * external server.
956   *
957   * @return  The total number of add operations attempted against the LDAP
958   *          external server, or {@code null} if it was not included in the
959   *          monitor entry.
960   */
961  public Long getAddAttempts()
962  {
963    return addAttempts;
964  }
965
966
967
968  /**
969   * Retrieves the number of failed add attempts against the LDAP external
970   * server.
971   *
972   * @return  The number of failed add attempts against the LDAP external
973   *          server, or {@code null} if it was not included in the monitor
974   *          entry.
975   */
976  public Long getAddFailures()
977  {
978    return addFailures;
979  }
980
981
982
983  /**
984   * Retrieves the number of successful add attempts against the LDAP external
985   * server.
986   *
987   * @return  The number of successful add attempts against the LDAP external
988   *          server, or {@code null} if it was not included in the monitor
989   *          entry.
990   */
991  public Long getAddSuccesses()
992  {
993    return addSuccesses;
994  }
995
996
997
998  /**
999   * Retrieves the total number of bind operations attempted against the LDAP
1000   * external server.
1001   *
1002   * @return  The total number of bind operations attempted against the LDAP
1003   *          external server, or {@code null} if it was not included in the
1004   *          monitor entry.
1005   */
1006  public Long getBindAttempts()
1007  {
1008    return bindAttempts;
1009  }
1010
1011
1012
1013  /**
1014   * Retrieves the number of failed bind attempts against the LDAP external
1015   * server.
1016   *
1017   * @return  The number of failed bind attempts against the LDAP external
1018   *          server, or {@code null} if it was not included in the monitor
1019   *          entry.
1020   */
1021  public Long getBindFailures()
1022  {
1023    return bindFailures;
1024  }
1025
1026
1027
1028  /**
1029   * Retrieves the number of successful bind attempts against the LDAP external
1030   * server.
1031   *
1032   * @return  The number of successful bind attempts against the LDAP external
1033   *          server, or {@code null} if it was not included in the monitor
1034   *          entry.
1035   */
1036  public Long getBindSuccesses()
1037  {
1038    return bindSuccesses;
1039  }
1040
1041
1042
1043  /**
1044   * Retrieves the total number of compare operations attempted against the LDAP
1045   * external server.
1046   *
1047   * @return  The total number of compare operations attempted against the LDAP
1048   *          external server, or {@code null} if it was not included in the
1049   *          monitor entry.
1050   */
1051  public Long getCompareAttempts()
1052  {
1053    return compareAttempts;
1054  }
1055
1056
1057
1058  /**
1059   * Retrieves the number of failed compare attempts against the LDAP external
1060   * server.
1061   *
1062   * @return  The number of failed compare attempts against the LDAP external
1063   *          server, or {@code null} if it was not included in the monitor
1064   *          entry.
1065   */
1066  public Long getCompareFailures()
1067  {
1068    return compareFailures;
1069  }
1070
1071
1072
1073  /**
1074   * Retrieves the number of successful compare attempts against the LDAP
1075   * external server.
1076   *
1077   * @return  The number of successful compare attempts against the LDAP
1078   *          external server, or {@code null} if it was not included in the
1079   *          monitor entry.
1080   */
1081  public Long getCompareSuccesses()
1082  {
1083    return compareSuccesses;
1084  }
1085
1086
1087
1088  /**
1089   * Retrieves the total number of delete operations attempted against the LDAP
1090   * external server.
1091   *
1092   * @return  The total number of delete operations attempted against the LDAP
1093   *          external server, or {@code null} if it was not included in the
1094   *          monitor entry.
1095   */
1096  public Long getDeleteAttempts()
1097  {
1098    return deleteAttempts;
1099  }
1100
1101
1102
1103  /**
1104   * Retrieves the number of failed delete attempts against the LDAP external
1105   * server.
1106   *
1107   * @return  The number of failed delete attempts against the LDAP external
1108   *          server, or {@code null} if it was not included in the monitor
1109   *          entry.
1110   */
1111  public Long getDeleteFailures()
1112  {
1113    return deleteFailures;
1114  }
1115
1116
1117
1118  /**
1119   * Retrieves the number of successful delete attempts against the LDAP
1120   * external server.
1121   *
1122   * @return  The number of successful delete attempts against the LDAP
1123   *          external server, or {@code null} if it was not included in the
1124   *          monitor entry.
1125   */
1126  public Long getDeleteSuccesses()
1127  {
1128    return deleteSuccesses;
1129  }
1130
1131
1132
1133  /**
1134   * Retrieves the total number of modify operations attempted against the LDAP
1135   * external server.
1136   *
1137   * @return  The total number of modify operations attempted against the LDAP
1138   *          external server, or {@code null} if it was not included in the
1139   *          monitor entry.
1140   */
1141  public Long getModifyAttempts()
1142  {
1143    return modifyAttempts;
1144  }
1145
1146
1147
1148  /**
1149   * Retrieves the number of failed modify attempts against the LDAP external
1150   * server.
1151   *
1152   * @return  The number of failed modify attempts against the LDAP external
1153   *          server, or {@code null} if it was not included in the monitor
1154   *          entry.
1155   */
1156  public Long getModifyFailures()
1157  {
1158    return modifyFailures;
1159  }
1160
1161
1162
1163  /**
1164   * Retrieves the number of successful modify attempts against the LDAP
1165   * external server.
1166   *
1167   * @return  The number of successful modify attempts against the LDAP
1168   *          external server, or {@code null} if it was not included in the
1169   *          monitor entry.
1170   */
1171  public Long getModifySuccesses()
1172  {
1173    return modifySuccesses;
1174  }
1175
1176
1177
1178  /**
1179   * Retrieves the total number of modify DN operations attempted against the
1180   * LDAP external server.
1181   *
1182   * @return  The total number of modify DN operations attempted against the
1183   *          LDAP external server, or {@code null} if it was not included in
1184   *          the monitor entry.
1185   */
1186  public Long getModifyDNAttempts()
1187  {
1188    return modifyDNAttempts;
1189  }
1190
1191
1192
1193  /**
1194   * Retrieves the number of failed modify DN attempts against the LDAP external
1195   * server.
1196   *
1197   * @return  The number of failed modify DN attempts against the LDAP external
1198   *          server, or {@code null} if it was not included in the monitor
1199   *          entry.
1200   */
1201  public Long getModifyDNFailures()
1202  {
1203    return modifyDNFailures;
1204  }
1205
1206
1207
1208  /**
1209   * Retrieves the number of successful modify DN attempts against the LDAP
1210   * external server.
1211   *
1212   * @return  The number of successful modify DN attempts against the LDAP
1213   *          external server, or {@code null} if it was not included in the
1214   *          monitor entry.
1215   */
1216  public Long getModifyDNSuccesses()
1217  {
1218    return modifyDNSuccesses;
1219  }
1220
1221
1222
1223  /**
1224   * Retrieves the total number of search operations attempted against the LDAP
1225   * external server.
1226   *
1227   * @return  The total number of search operations attempted against the LDAP
1228   *          external server, or {@code null} if it was not included in the
1229   *          monitor entry.
1230   */
1231  public Long getSearchAttempts()
1232  {
1233    return searchAttempts;
1234  }
1235
1236
1237
1238  /**
1239   * Retrieves the number of failed search attempts against the LDAP external
1240   * server.
1241   *
1242   * @return  The number of failed search attempts against the LDAP external
1243   *          server, or {@code null} if it was not included in the monitor
1244   *          entry.
1245   */
1246  public Long getSearchFailures()
1247  {
1248    return searchFailures;
1249  }
1250
1251
1252
1253  /**
1254   * Retrieves the number of successful search attempts against the LDAP
1255   * external server.
1256   *
1257   * @return  The number of successful search attempts against the LDAP
1258   *          external server, or {@code null} if it was not included in the
1259   *          monitor entry.
1260   */
1261  public Long getSearchSuccesses()
1262  {
1263    return searchSuccesses;
1264  }
1265
1266
1267
1268  /**
1269   * Retrieves the number of currently available connections in the common
1270   * connection pool used by the LDAP external server used for both bind and
1271   * non-bind operations.
1272   *
1273   * @return  The number of currently available connections in the common
1274   *          connection pool used by the LDAP external server used for both
1275   *          bind and non-bind operations, or {@code null} if it was not
1276   *          included in the monitor entry or if the external server uses
1277   *          separate pools for bind and non-bind operations.
1278   */
1279  public Long getCommonPoolAvailableConnections()
1280  {
1281    return commonPoolAvailableConnections;
1282  }
1283
1284
1285
1286  /**
1287   * Retrieves the maximum number of connections that may be available in the
1288   * common connection pool used by the LDAP external server for both bind and
1289   * non-bind operations.
1290   *
1291   * @return  The maximum number of connections that may be available in the
1292   *          common connection pool used by the LDAP external server for both
1293   *          bind and non-bind operations, or {@code null} if it was not
1294   *          included in the monitor entry or if the external server uses
1295   *          separate pools for bind and non-bind operations.
1296   */
1297  public Long getCommonPoolMaxAvailableConnections()
1298  {
1299    return commonPoolMaxAvailableConnections;
1300  }
1301
1302
1303
1304  /**
1305   * Retrieves the number of successful connection attempts in the common
1306   * connection pool used by the LDAP external server for both bind and non-bind
1307   * operations.
1308   *
1309   * @return  The number of successful connection attempts in the common
1310   *          connection pool used by the LDAP external server for both bind and
1311   *          non-bind operations, or {@code null} if it was not included in the
1312   *          monitor entry or if the external server uses separate pools for
1313   *          bind and non-bind operations.
1314   */
1315  public Long getCommonPoolNumSuccessfulConnectionAttempts()
1316  {
1317    return commonPoolNumSuccessfulConnectionAttempts;
1318  }
1319
1320
1321
1322  /**
1323   * Retrieves the number of failed connection attempts in the common connection
1324   * pool used by the LDAP external server for both bind and non-bind
1325   * operations.
1326   *
1327   * @return  The number of failed connection attempts in the common connection
1328   *          pool used by the LDAP external server for both bind and non-bind
1329   *          operations, or {@code null} if it was not included in the monitor
1330   *          entry or if the external server uses separate pools for bind and
1331   *          non-bind operations.
1332   */
1333  public Long getCommonPoolNumFailedConnectionAttempts()
1334  {
1335    return commonPoolNumFailedConnectionAttempts;
1336  }
1337
1338
1339
1340  /**
1341   * Retrieves the number of connections in the common connection pool used by
1342   * the LDAP external server for both bind and non-bind operations that have
1343   * been closed as defunct.
1344   *
1345   * @return  The number of connections in the common connection pool used by
1346   *          the LDAP external server for both bind and non-bind operations
1347   *          that have been closed as defunct, or {@code null} if it was not
1348   *          included in the monitor entry or if the external server uses
1349   *          separate pools for bind and non-bind operations.
1350   */
1351  public Long getCommonPoolNumClosedDefunct()
1352  {
1353    return commonPoolNumClosedDefunct;
1354  }
1355
1356
1357
1358  /**
1359   * Retrieves the number of connections in the common connection pool used by
1360   * the LDAP external server for processing both bind and non-bind operations
1361   * that have been closed as expired.
1362   *
1363   * @return  The number of connections in the common connection pool used by
1364   *          the LDAP external server for both bind and non-bind operations
1365   *          that have been closed as expired, or {@code null} if it was not
1366   *          included in the monitor entry or if the external server uses
1367   *          separate pools for bind and non-bind operations.
1368   */
1369  public Long getCommonPoolNumClosedExpired()
1370  {
1371    return commonPoolNumClosedExpired;
1372  }
1373
1374
1375
1376  /**
1377   * Retrieves the number of connections in the common connection pool used by
1378   * the LDAP external server for both bind and non-bind operations that have
1379   * been closed as unneeded.
1380   *
1381   * @return  The number of connections in the common connection pool used by
1382   *          the LDAP external server for both bind and non-bind operations
1383   *          that have been closed as unneeded, or {@code null} if it was not
1384   *          included in the monitor entry or if the external server uses
1385   *          separate pools for bind and non-bind operations.
1386   */
1387  public Long getCommonPoolNumClosedUnneeded()
1388  {
1389    return commonPoolNumClosedUnneeded;
1390  }
1391
1392
1393
1394  /**
1395   * Retrieves the total number of successful checkouts from the common
1396   * connection pool used by the LDAP external server for both bind and non-bind
1397   * operations.
1398   *
1399   * @return  The total number of successful checkouts from the common
1400   *          connection pool used by the LDAP external server for both bind and
1401   *          non-bind operations, or {@code null} if it was not included in the
1402   *          monitor entry or if the external server uses separate pools for
1403   *          bind and non-bind operations.
1404   */
1405  public Long getCommonPoolTotalSuccessfulCheckouts()
1406  {
1407    return commonPoolNumSuccessfulCheckouts;
1408  }
1409
1410
1411
1412  /**
1413   * Retrieves the number of successful checkouts from the common connection
1414   * pool used by the LDAP external server for both bind and non-bind operations
1415   * in which an existing connection was retrieved without needing to wait.
1416   *
1417   * @return  The number of successful checkouts from the common connection pool
1418   *          used by the LDAP external server for both bind and non-bind
1419   *          operations in which an existing connection was retrieved without
1420   *          needing to wait, or {@code null} if it was not included in the
1421   *          monitor entry or if the external server uses separate pools for
1422   *          bind and non-bind operations.
1423   */
1424  public Long getCommonPoolNumSuccessfulCheckoutsWithoutWaiting()
1425  {
1426    return commonPoolNumSuccessfulCheckoutsWithoutWaiting;
1427  }
1428
1429
1430
1431  /**
1432   * Retrieves the number of successful checkouts from the common connection
1433   * pool used by the LDAP external server for both bind and non-bind operations
1434   * in which an existing connection was retrieved after waiting for the
1435   * connection to become available.
1436   *
1437   * @return  The number of successful checkouts from the common connection pool
1438   *          used by the LDAP external server for both bind and non-bind
1439   *          operations in which an existing connection was retrieved after
1440   *          waiting for the connection to become available, or {@code null} if
1441   *          it was not included in the monitor entry or if the external server
1442   *          uses separate pools for bind and non-bind operations.
1443   */
1444  public Long getCommonPoolNumSuccessfulCheckoutsAfterWaiting()
1445  {
1446    return commonPoolNumSuccessfulCheckoutsAfterWaiting;
1447  }
1448
1449
1450
1451  /**
1452   * Retrieves the number of successful checkouts from the common connection
1453   * pool used by the LDAP external server for both bind and non-bind operations
1454   * in which an existing connection was retrieved after creating a new
1455   * connection.
1456   *
1457   * @return  The number of successful checkouts from the common connection pool
1458   *          used by the LDAP external server for both bind and non-bind
1459   *          operations in which an existing connection was retrieved after
1460   *          creating a new connection, or {@code null} if it was not included
1461   *          in the monitor entry or if the external server uses separate pools
1462   *          for bind and non-bind operations.
1463   */
1464  public Long getCommonPoolNumSuccessfulCheckoutsNewConnection()
1465  {
1466    return commonPoolNumSuccessfulCheckoutsNewConnection;
1467  }
1468
1469
1470
1471  /**
1472   * Retrieves the number of failed checkout attempts from the common connection
1473   * pool used by the LDAP external server for both bind and non-bind
1474   * operations.
1475   *
1476   * @return  The number of failed checkout attempts from the common connection
1477   *          pool used by the LDAP external server for both bind and non-bind
1478   *          operations, or {@code null} if it was not included in the monitor
1479   *          entry or if the external server uses separate pools for bind and
1480   *          non-bind operations.
1481   */
1482  public Long getCommonPoolNumFailedCheckouts()
1483  {
1484    return commonPoolNumFailedCheckouts;
1485  }
1486
1487
1488
1489  /**
1490   * Retrieves the number of connections released as valid back to the common
1491   * connection pool used by the LDAP external server for bind and non-bind
1492   * operations.
1493   *
1494   * @return  The number of connections released as valid back to the common
1495   *          connection pool used by the LDAP external server used for bind and
1496   *          non-bind operations, or {@code null} if it was not included in the
1497   *          monitor entry or if the external server uses a separate pools for
1498   *          bind and non-bind operations.
1499   */
1500  public Long getCommonPoolNumReleasedValid()
1501  {
1502    return commonPoolNumReleasedValid;
1503  }
1504
1505
1506
1507  /**
1508   * Retrieves the number of currently available connections in the bind
1509   * connection pool used by the LDAP external server.
1510   *
1511   * @return  The number of currently available connections in the bind
1512   *          connection pool used by the LDAP external server, or {@code null}
1513   *          if it was not included in the monitor entry or if the external
1514   *          server uses a common pool for bind and non-bind operations.
1515   */
1516  public Long getBindPoolAvailableConnections()
1517  {
1518    return bindPoolAvailableConnections;
1519  }
1520
1521
1522
1523  /**
1524   * Retrieves the maximum number of connections that may be available in the
1525   * bind connection pool used by the LDAP external server.
1526   *
1527   * @return  The maximum number of connections that may be available in the
1528   *          bind connection pool used by the LDAP external server, or
1529   *          {@code null} if it was not included in the monitor entry or if the
1530   *          external server uses a common pool for bind and non-bind
1531   *          operations.
1532   */
1533  public Long getBindPoolMaxAvailableConnections()
1534  {
1535    return bindPoolMaxAvailableConnections;
1536  }
1537
1538
1539
1540  /**
1541   * Retrieves the number of successful connection attempts in the bind
1542   * connection pool used by the LDAP external server.
1543   *
1544   * @return  The number of successful connection attempts in the bind
1545   *          connection pool used by the LDAP external server, or {@code null}
1546   *          if it was not included in the monitor entry or if the external
1547   *          server uses a common pool for bind and non-bind operations.
1548   */
1549  public Long getBindPoolNumSuccessfulConnectionAttempts()
1550  {
1551    return bindPoolNumSuccessfulConnectionAttempts;
1552  }
1553
1554
1555
1556  /**
1557   * Retrieves the number of failed connection attempts in the bind connection
1558   * pool used by the LDAP external server.
1559   *
1560   * @return  The number of failed connection attempts in the bind connection
1561   *          pool used by the LDAP external server, or {@code null} if it was
1562   *          not included in the monitor entry or if the external server uses a
1563   *          common pool for bind and non-bind operations.
1564   */
1565  public Long getBindPoolNumFailedConnectionAttempts()
1566  {
1567    return bindPoolNumFailedConnectionAttempts;
1568  }
1569
1570
1571
1572  /**
1573   * Retrieves the number of connections in the bind connection pool used by the
1574   * LDAP external server that have been closed as defunct.
1575   *
1576   * @return  The number of connections in the bind connection pool used by the
1577   *          LDAP external server that have been closed as defunct, or
1578   *          {@code null} if it was not included in the monitor entry or if the
1579   *          external server uses a common pool for bind and non-bind
1580   *          operations.
1581   */
1582  public Long getBindPoolNumClosedDefunct()
1583  {
1584    return bindPoolNumClosedDefunct;
1585  }
1586
1587
1588
1589  /**
1590   * Retrieves the number of connections in the bind connection pool used by the
1591   * LDAP external server that have been closed as expired.
1592   *
1593   * @return  The number of connections in the bind connection pool used by the
1594   *          LDAP external server that have been closed as expired, or
1595   *          {@code null} if it was not included in the monitor entry or if the
1596   *          external server uses a common pool for bind and non-bind
1597   *          operations.
1598   */
1599  public Long getBindPoolNumClosedExpired()
1600  {
1601    return bindPoolNumClosedExpired;
1602  }
1603
1604
1605
1606  /**
1607   * Retrieves the number of connections in the bind connection pool used by the
1608   * LDAP external server that have been closed as unneeded.
1609   *
1610   * @return  The number of connections in the bind connection pool used by the
1611   *          LDAP external server that have been closed as unneeded, or
1612   *          {@code null} if it was not included in the monitor entry or if the
1613   *          external server uses a common pool for bind and non-bind
1614   *          operations.
1615   */
1616  public Long getBindPoolNumClosedUnneeded()
1617  {
1618    return bindPoolNumClosedUnneeded;
1619  }
1620
1621
1622
1623  /**
1624   * Retrieves the total number of successful checkouts from the bind connection
1625   * pool used by the LDAP external server.
1626   *
1627   * @return  The total number of successful checkouts from the bind connection
1628   *          pool used by the LDAP external server, or {@code null} if it was
1629   *          not included in the monitor entry or if the external server uses a
1630   *          common pool for bind and non-bind operations.
1631   */
1632  public Long getBindPoolTotalSuccessfulCheckouts()
1633  {
1634    return bindPoolNumSuccessfulCheckouts;
1635  }
1636
1637
1638
1639  /**
1640   * Retrieves the number of successful checkouts from the bind connection pool
1641   * used by the LDAP external server in which an existing connection was
1642   * retrieved without needing to wait.
1643   *
1644   * @return  The number of successful checkouts from the bind connection pool
1645   *          used by the LDAP external server in which an existing connection
1646   *          was retrieved without needing to wait, or {@code null} if it was
1647   *          not included in the monitor entry or if the external server uses a
1648   *          common pool for bind and non-bind operations.
1649   */
1650  public Long getBindPoolNumSuccessfulCheckoutsWithoutWaiting()
1651  {
1652    return bindPoolNumSuccessfulCheckoutsWithoutWaiting;
1653  }
1654
1655
1656
1657  /**
1658   * Retrieves the number of successful checkouts from the bind connection pool
1659   * used by the LDAP external server in which an existing connection was
1660   * retrieved after waiting for the connection to become available.
1661   *
1662   * @return  The number of successful checkouts from the bind connection pool
1663   *          used by the LDAP external server in which an existing connection
1664   *          was retrieved after waiting for the connection to become
1665   *          available, or {@code null} if it was not included in the monitor
1666   *          entry or if the external server uses a common pool for bind and
1667   *          non-bind operations.
1668   */
1669  public Long getBindPoolNumSuccessfulCheckoutsAfterWaiting()
1670  {
1671    return bindPoolNumSuccessfulCheckoutsAfterWaiting;
1672  }
1673
1674
1675
1676  /**
1677   * Retrieves the number of successful checkouts from the bind connection pool
1678   * used by the LDAP external server in which an existing connection was
1679   * retrieved after creating a new connection.
1680   *
1681   * @return  The number of successful checkouts from the bind connection pool
1682   *          used by the LDAP external server in which an existing connection
1683   *          was retrieved after creating a new connection, or {@code null} if
1684   *          it was not included in the monitor entry or if the external server
1685   *          uses a common pool for bind and non-bind operations.
1686   */
1687  public Long getBindPoolNumSuccessfulCheckoutsNewConnection()
1688  {
1689    return bindPoolNumSuccessfulCheckoutsNewConnection;
1690  }
1691
1692
1693
1694  /**
1695   * Retrieves the number of failed checkout attempts from the bind connection
1696   * pool used by the LDAP external server.
1697   *
1698   * @return  The number of failed checkout attempts from the bind connection
1699   *          pool used by the LDAP external server, or {@code null} if it was
1700   *          not included in the monitor entry or if the external server uses a
1701   *          common pool for bind and non-bind operations.
1702   */
1703  public Long getBindPoolNumFailedCheckouts()
1704  {
1705    return bindPoolNumFailedCheckouts;
1706  }
1707
1708
1709
1710  /**
1711   * Retrieves the number of connections released as valid back to the bind
1712   * connection pool used by the LDAP external server.
1713   *
1714   * @return  The number of connections released as valid back to the bind
1715   *          connection pool used by the LDAP external server, or {@code null}
1716   *          if it was not included in the monitor entry or if the external
1717   *          server uses a common pool for bind and non-bind operations.
1718   */
1719  public Long getBindPoolNumReleasedValid()
1720  {
1721    return bindPoolNumReleasedValid;
1722  }
1723
1724
1725
1726  /**
1727   * Retrieves the number of currently available connections in the non-bind
1728   * connection pool used by the LDAP external server.
1729   *
1730   * @return  The number of currently available connections in the non-bind
1731   *          connection pool used by the LDAP external server, or {@code null}
1732   *          if it was not included in the monitor entry or if the external
1733   *          server uses a common pool for bind and non-bind operations.
1734   */
1735  public Long getNonBindPoolAvailableConnections()
1736  {
1737    return nonBindPoolAvailableConnections;
1738  }
1739
1740
1741
1742  /**
1743   * Retrieves the maximum number of connections that may be available in the
1744   * non-bind connection pool used by the LDAP external server.
1745   *
1746   * @return  The maximum number of connections that may be available in the
1747   *          non-bind connection pool used by the LDAP external server, or
1748   *          {@code null} if it was not included in the monitor entry or if the
1749   *          external server uses a common pool for bind and non-bind
1750   *          operations.
1751   */
1752  public Long getNonBindPoolMaxAvailableConnections()
1753  {
1754    return nonBindPoolMaxAvailableConnections;
1755  }
1756
1757
1758
1759  /**
1760   * Retrieves the number of successful connection attempts in the non-bind
1761   * connection pool used by the LDAP external server.
1762   *
1763   * @return  The number of successful connection attempts in the non-bind
1764   *          connection pool used by the LDAP external server, or {@code null}
1765   *          if it was not included in the monitor entry or if the external
1766   *          server uses a common pool for bind and non-bind operations.
1767   */
1768  public Long getNonBindPoolNumSuccessfulConnectionAttempts()
1769  {
1770    return nonBindPoolNumSuccessfulConnectionAttempts;
1771  }
1772
1773
1774
1775  /**
1776   * Retrieves the number of failed connection attempts in the non-bind
1777   * connection pool used by the LDAP external server.
1778   *
1779   * @return  The number of failed connection attempts in the non-bind
1780   *          connection pool used by the LDAP external server, or {@code null}
1781   *          if it was not included in the monitor entry or if the external
1782   *          server uses a common pool for bind and non-bind operations.
1783   */
1784  public Long getNonBindPoolNumFailedConnectionAttempts()
1785  {
1786    return nonBindPoolNumFailedConnectionAttempts;
1787  }
1788
1789
1790
1791  /**
1792   * Retrieves the number of connections in the non-bind connection pool used by
1793   * the LDAP external server that have been closed as defunct.
1794   *
1795   * @return  The number of connections in the non-bind connection pool used by
1796   *          the LDAP external server that have been closed as defunct, or
1797   *          {@code null} if it was not included in the monitor entry or if the
1798   *          external server uses a common pool for bind and non-bind
1799   *          operations.
1800   */
1801  public Long getNonBindPoolNumClosedDefunct()
1802  {
1803    return nonBindPoolNumClosedDefunct;
1804  }
1805
1806
1807
1808  /**
1809   * Retrieves the number of connections in the non-bind connection pool used by
1810   * the LDAP external server that have been closed as expired.
1811   *
1812   * @return  The number of connections in the non-bind connection pool used by
1813   *          the LDAP external server that have been closed as expired, or
1814   *          {@code null} if it was not included in the monitor entry or if the
1815   *          external server uses a common pool for bind and non-bind
1816   *          operations.
1817   */
1818  public Long getNonBindPoolNumClosedExpired()
1819  {
1820    return nonBindPoolNumClosedExpired;
1821  }
1822
1823
1824
1825  /**
1826   * Retrieves the number of connections in the non-bind connection pool used by
1827   * the LDAP external server that have been closed as unneeded.
1828   *
1829   * @return  The number of connections in the non-bind connection pool used by
1830   *          the LDAP external server that have been closed as unneeded, or
1831   *          {@code null} if it was not included in the monitor entry or if the
1832   *          external server uses a common pool for bind and non-bind
1833   *          operations.
1834   */
1835  public Long getNonBindPoolNumClosedUnneeded()
1836  {
1837    return nonBindPoolNumClosedUnneeded;
1838  }
1839
1840
1841
1842  /**
1843   * Retrieves the total number of successful checkouts from the non-bind
1844   * connection pool used by the LDAP external server.
1845   *
1846   * @return  The total number of successful checkouts from the non-bind
1847   *          connection pool used by the LDAP external server, or {@code null}
1848   *          if it was not included in the monitor entry or if the external
1849   *          server uses a common pool for bind and non-bind operations.
1850   */
1851  public Long getNonBindPoolTotalSuccessfulCheckouts()
1852  {
1853    return nonBindPoolNumSuccessfulCheckouts;
1854  }
1855
1856
1857
1858  /**
1859   * Retrieves the number of successful checkouts from the non-bind connection
1860   * pool used by the LDAP external server in which an existing connection was
1861   * retrieved without needing to wait.
1862   *
1863   * @return  The number of successful checkouts from the non-bind connection
1864   *          pool used by the LDAP external server in which an existing
1865   *          connection was retrieved without needing to wait, or {@code null}
1866   *          if it was not included in the monitor entry or if the external
1867   *          server uses a common pool for bind and non-bind operations.
1868   */
1869  public Long getNonBindPoolNumSuccessfulCheckoutsWithoutWaiting()
1870  {
1871    return nonBindPoolNumSuccessfulCheckoutsWithoutWaiting;
1872  }
1873
1874
1875
1876  /**
1877   * Retrieves the number of successful checkouts from the non-bind connection
1878   * pool used by the LDAP external server in which an existing connection was
1879   * retrieved after waiting for the connection to become available.
1880   *
1881   * @return  The number of successful checkouts from the non-bind connection
1882   *          pool used by the LDAP external server in which an existing
1883   *          connection was retrieved after waiting for the connection to
1884   *          become available, or {@code null} if it was not included in the
1885   *          monitor entry or if the external server uses a common pool for
1886   *          bind and non-bind operations.
1887   */
1888  public Long getNonBindPoolNumSuccessfulCheckoutsAfterWaiting()
1889  {
1890    return nonBindPoolNumSuccessfulCheckoutsAfterWaiting;
1891  }
1892
1893
1894
1895  /**
1896   * Retrieves the number of successful checkouts from the non-bind connection
1897   * pool used by the LDAP external server in which an existing connection was
1898   * retrieved after creating a new connection.
1899   *
1900   * @return  The number of successful checkouts from the non-bind connection
1901   *          pool used by the LDAP external server in which an existing
1902   *          connection was retrieved after creating a new connection, or
1903   *          {@code null} if it was not included in the monitor entry or if the
1904   *          external server uses a common pool for bind and non-bind
1905   *          operations.
1906   */
1907  public Long getNonBindPoolNumSuccessfulCheckoutsNewConnection()
1908  {
1909    return nonBindPoolNumSuccessfulCheckoutsNewConnection;
1910  }
1911
1912
1913
1914  /**
1915   * Retrieves the number of failed checkout attempts from the non-bind
1916   * connection pool used by the LDAP external server.
1917   *
1918   * @return  The number of failed checkout attempts from the non-bind
1919   *          connection pool used by the LDAP external server, or {@code null}
1920   *          if it was not included in the monitor entry or if the external
1921   *          server uses a common pool for bind and non-bind operations.
1922   */
1923  public Long getNonBindPoolNumFailedCheckouts()
1924  {
1925    return nonBindPoolNumFailedCheckouts;
1926  }
1927
1928
1929
1930  /**
1931   * Retrieves the number of connections released as valid back to the non-bind
1932   * connection pool used by the LDAP external server.
1933   *
1934   * @return  The number of connections released as valid back to the non-bind
1935   *          connection pool used by the LDAP external server, or {@code null}
1936   *          if it was not included in the monitor entry or if the external
1937   *          server uses a common pool for bind and non-bind operations.
1938   */
1939  public Long getNonBindPoolNumReleasedValid()
1940  {
1941    return nonBindPoolNumReleasedValid;
1942  }
1943
1944
1945
1946  /**
1947   * {@inheritDoc}
1948   */
1949  @Override()
1950  public String getMonitorDisplayName()
1951  {
1952    return INFO_LDAP_EXT_SERVER_MONITOR_DISPNAME.get();
1953  }
1954
1955
1956
1957  /**
1958   * {@inheritDoc}
1959   */
1960  @Override()
1961  public String getMonitorDescription()
1962  {
1963    return INFO_LDAP_EXT_SERVER_MONITOR_DESC.get();
1964  }
1965
1966
1967
1968  /**
1969   * {@inheritDoc}
1970   */
1971  @Override()
1972  public Map<String,MonitorAttribute> getMonitorAttributes()
1973  {
1974    final LinkedHashMap<String,MonitorAttribute> attrs =
1975         new LinkedHashMap<>(StaticUtils.computeMapCapacity(50));
1976
1977    if (serverAddress != null)
1978    {
1979      addMonitorAttribute(attrs,
1980           ATTR_SERVER_ADDRESS,
1981           INFO_LDAP_EXT_SERVER_DISPNAME_SERVER_ADDRESS.get(),
1982           INFO_LDAP_EXT_SERVER_DESC_SERVER_ADDRESS.get(),
1983           serverAddress);
1984    }
1985
1986    if (serverPort != null)
1987    {
1988      addMonitorAttribute(attrs,
1989           ATTR_SERVER_PORT,
1990           INFO_LDAP_EXT_SERVER_DISPNAME_SERVER_PORT.get(),
1991           INFO_LDAP_EXT_SERVER_DESC_SERVER_PORT.get(),
1992           serverPort);
1993    }
1994
1995    if (communicationSecurity != null)
1996    {
1997      addMonitorAttribute(attrs,
1998           ATTR_COMMUNICATION_SECURITY,
1999           INFO_LDAP_EXT_SERVER_DISPNAME_COMMUNICATION_SECURITY.get(),
2000           INFO_LDAP_EXT_SERVER_DESC_COMMUNICATION_SECURITY.get(),
2001           communicationSecurity);
2002    }
2003
2004    if (loadBalancingAlgorithmDN != null)
2005    {
2006      addMonitorAttribute(attrs,
2007           ATTR_LOAD_BALANCING_ALGORITHM_DN,
2008           INFO_LDAP_EXT_SERVER_DISPNAME_LOAD_BALANCING_ALGORITHM_DN.get(),
2009           INFO_LDAP_EXT_SERVER_DESC_LOAD_BALANCING_ALGORITHM_DN.get(),
2010           loadBalancingAlgorithmDN);
2011    }
2012
2013    if (healthCheckState != null)
2014    {
2015      addMonitorAttribute(attrs,
2016           ATTR_HEALTH_CHECK_STATE,
2017           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_STATE.get(),
2018           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_STATE.get(),
2019           healthCheckState.getName());
2020    }
2021
2022    if (healthCheckScore != null)
2023    {
2024      addMonitorAttribute(attrs,
2025           ATTR_HEALTH_CHECK_SCORE,
2026           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_SCORE.get(),
2027           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_SCORE.get(),
2028           healthCheckScore);
2029    }
2030
2031    if ((healthCheckMessages != null) && (! healthCheckMessages.isEmpty()))
2032    {
2033      addMonitorAttribute(attrs,
2034           ATTR_HEALTH_CHECK_MESSAGE,
2035           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_MESSAGE.get(),
2036           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_MESSAGE.get(),
2037           healthCheckMessages);
2038    }
2039
2040    if (healthCheckUpdateTime != null)
2041    {
2042      addMonitorAttribute(attrs,
2043           ATTR_HEALTH_CHECK_UPDATE_TIME,
2044           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_UPDATE_TIME.get(),
2045           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_UPDATE_TIME.get(),
2046           healthCheckUpdateTime);
2047    }
2048
2049    if (commonPoolAvailableConnections != null)
2050    {
2051      addMonitorAttribute(attrs,
2052           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_AVAILABLE_CONNS,
2053           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_AVAILABLE_CONNS.get(),
2054           INFO_LDAP_EXT_SERVER_DESC_COMMON_AVAILABLE_CONNS.get(),
2055           commonPoolAvailableConnections);
2056    }
2057
2058    if (commonPoolMaxAvailableConnections != null)
2059    {
2060      addMonitorAttribute(attrs,
2061           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_MAX_AVAILABLE_CONNS,
2062           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_MAX_AVAILABLE_CONNS.get(),
2063           INFO_LDAP_EXT_SERVER_DESC_COMMON_MAX_AVAILABLE_CONNS.get(),
2064           commonPoolMaxAvailableConnections);
2065    }
2066
2067    if (commonPoolNumSuccessfulConnectionAttempts != null)
2068    {
2069      addMonitorAttribute(attrs,
2070           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS,
2071           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CONNECT_SUCCESS.get(),
2072           INFO_LDAP_EXT_SERVER_DESC_COMMON_CONNECT_SUCCESS.get(),
2073           commonPoolNumSuccessfulConnectionAttempts);
2074    }
2075
2076    if (commonPoolNumFailedConnectionAttempts != null)
2077    {
2078      addMonitorAttribute(attrs,
2079           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_FAILED_CONNECTS,
2080           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CONNECT_FAILED.get(),
2081           INFO_LDAP_EXT_SERVER_DESC_COMMON_CONNECT_FAILED.get(),
2082           commonPoolNumFailedConnectionAttempts);
2083    }
2084
2085    if (commonPoolNumClosedDefunct != null)
2086    {
2087      addMonitorAttribute(attrs,
2088           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_CLOSED_DEFUNCT,
2089           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CLOSED_DEFUNCT.get(),
2090           INFO_LDAP_EXT_SERVER_DESC_COMMON_CLOSED_DEFUNCT.get(),
2091           commonPoolNumClosedDefunct);
2092    }
2093
2094    if (commonPoolNumClosedExpired != null)
2095    {
2096      addMonitorAttribute(attrs,
2097           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_CLOSED_EXPIRED,
2098           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CLOSED_EXPIRED.get(),
2099           INFO_LDAP_EXT_SERVER_DESC_COMMON_CLOSED_EXPIRED.get(),
2100           commonPoolNumClosedExpired);
2101    }
2102
2103    if (commonPoolNumClosedUnneeded != null)
2104    {
2105      addMonitorAttribute(attrs,
2106           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_CLOSED_UNNEEDED,
2107           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CLOSED_UNNEEDED.get(),
2108           INFO_LDAP_EXT_SERVER_DESC_COMMON_CLOSED_UNNEEDED.get(),
2109           commonPoolNumClosedUnneeded);
2110    }
2111
2112    if (commonPoolNumSuccessfulCheckouts != null)
2113    {
2114      addMonitorAttribute(attrs,
2115           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS,
2116           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_SUCCESS.get(),
2117           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_SUCCESS.get(),
2118           commonPoolNumSuccessfulCheckouts);
2119    }
2120
2121    if (commonPoolNumSuccessfulCheckoutsWithoutWaiting != null)
2122    {
2123      addMonitorAttribute(attrs,
2124           ATTR_PREFIX_COMMON_POOL +
2125                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING,
2126           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_NO_WAIT.get(),
2127           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_NO_WAIT.get(),
2128           commonPoolNumSuccessfulCheckoutsWithoutWaiting);
2129    }
2130
2131    if (commonPoolNumSuccessfulCheckoutsAfterWaiting != null)
2132    {
2133      addMonitorAttribute(attrs,
2134           ATTR_PREFIX_COMMON_POOL +
2135                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING,
2136           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_WITH_WAIT.get(),
2137           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_WITH_WAIT.get(),
2138           commonPoolNumSuccessfulCheckoutsAfterWaiting);
2139    }
2140
2141    if (commonPoolNumSuccessfulCheckoutsNewConnection != null)
2142    {
2143      addMonitorAttribute(attrs,
2144           ATTR_PREFIX_COMMON_POOL +
2145                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN,
2146           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_NEW_CONN.get(),
2147           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_NEW_CONN.get(),
2148           commonPoolNumSuccessfulCheckoutsNewConnection);
2149    }
2150
2151    if (commonPoolNumFailedCheckouts != null)
2152    {
2153      addMonitorAttribute(attrs,
2154           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_FAILED_CHECKOUTS,
2155           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_FAILED.get(),
2156           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_FAILED.get(),
2157           commonPoolNumFailedCheckouts);
2158    }
2159
2160    if (commonPoolNumReleasedValid != null)
2161    {
2162      addMonitorAttribute(attrs,
2163           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_RELEASED_VALID,
2164           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_RELEASED_VALID.get(),
2165           INFO_LDAP_EXT_SERVER_DESC_COMMON_RELEASED_VALID.get(),
2166           commonPoolNumReleasedValid);
2167    }
2168
2169    if (bindPoolAvailableConnections != null)
2170    {
2171      addMonitorAttribute(attrs,
2172           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_AVAILABLE_CONNS,
2173           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_AVAILABLE_CONNS.get(),
2174           INFO_LDAP_EXT_SERVER_DESC_BIND_AVAILABLE_CONNS.get(),
2175           bindPoolAvailableConnections);
2176    }
2177
2178    if (bindPoolMaxAvailableConnections != null)
2179    {
2180      addMonitorAttribute(attrs,
2181           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_MAX_AVAILABLE_CONNS,
2182           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_MAX_AVAILABLE_CONNS.get(),
2183           INFO_LDAP_EXT_SERVER_DESC_BIND_MAX_AVAILABLE_CONNS.get(),
2184           bindPoolMaxAvailableConnections);
2185    }
2186
2187    if (bindPoolNumSuccessfulConnectionAttempts != null)
2188    {
2189      addMonitorAttribute(attrs,
2190           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS,
2191           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CONNECT_SUCCESS.get(),
2192           INFO_LDAP_EXT_SERVER_DESC_BIND_CONNECT_SUCCESS.get(),
2193           bindPoolNumSuccessfulConnectionAttempts);
2194    }
2195
2196    if (bindPoolNumFailedConnectionAttempts != null)
2197    {
2198      addMonitorAttribute(attrs,
2199           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_FAILED_CONNECTS,
2200           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CONNECT_FAILED.get(),
2201           INFO_LDAP_EXT_SERVER_DESC_BIND_CONNECT_FAILED.get(),
2202           bindPoolNumFailedConnectionAttempts);
2203    }
2204
2205    if (bindPoolNumClosedDefunct != null)
2206    {
2207      addMonitorAttribute(attrs,
2208           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_CLOSED_DEFUNCT,
2209           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CLOSED_DEFUNCT.get(),
2210           INFO_LDAP_EXT_SERVER_DESC_BIND_CLOSED_DEFUNCT.get(),
2211           bindPoolNumClosedDefunct);
2212    }
2213
2214    if (bindPoolNumClosedExpired != null)
2215    {
2216      addMonitorAttribute(attrs,
2217           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_CLOSED_EXPIRED,
2218           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CLOSED_EXPIRED.get(),
2219           INFO_LDAP_EXT_SERVER_DESC_BIND_CLOSED_EXPIRED.get(),
2220           bindPoolNumClosedExpired);
2221    }
2222
2223    if (bindPoolNumClosedUnneeded != null)
2224    {
2225      addMonitorAttribute(attrs,
2226           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_CLOSED_UNNEEDED,
2227           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CLOSED_UNNEEDED.get(),
2228           INFO_LDAP_EXT_SERVER_DESC_BIND_CLOSED_UNNEEDED.get(),
2229           bindPoolNumClosedUnneeded);
2230    }
2231
2232    if (bindPoolNumSuccessfulCheckouts != null)
2233    {
2234      addMonitorAttribute(attrs,
2235           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS,
2236           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_SUCCESS.get(),
2237           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_SUCCESS.get(),
2238           bindPoolNumSuccessfulCheckouts);
2239    }
2240
2241    if (bindPoolNumSuccessfulCheckoutsWithoutWaiting != null)
2242    {
2243      addMonitorAttribute(attrs,
2244           ATTR_PREFIX_BIND_POOL +
2245                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING,
2246           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_NO_WAIT.get(),
2247           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_NO_WAIT.get(),
2248           bindPoolNumSuccessfulCheckoutsWithoutWaiting);
2249    }
2250
2251    if (bindPoolNumSuccessfulCheckoutsAfterWaiting != null)
2252    {
2253      addMonitorAttribute(attrs,
2254           ATTR_PREFIX_BIND_POOL +
2255                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING,
2256           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_WITH_WAIT.get(),
2257           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_WITH_WAIT.get(),
2258           bindPoolNumSuccessfulCheckoutsAfterWaiting);
2259    }
2260
2261    if (bindPoolNumSuccessfulCheckoutsNewConnection != null)
2262    {
2263      addMonitorAttribute(attrs,
2264           ATTR_PREFIX_BIND_POOL +
2265                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN,
2266           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_NEW_CONN.get(),
2267           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_NEW_CONN.get(),
2268           bindPoolNumSuccessfulCheckoutsNewConnection);
2269    }
2270
2271    if (bindPoolNumFailedCheckouts != null)
2272    {
2273      addMonitorAttribute(attrs,
2274           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_FAILED_CHECKOUTS,
2275           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_FAILED.get(),
2276           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_FAILED.get(),
2277           bindPoolNumFailedCheckouts);
2278    }
2279
2280    if (bindPoolNumReleasedValid != null)
2281    {
2282      addMonitorAttribute(attrs,
2283           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_RELEASED_VALID,
2284           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_RELEASED_VALID.get(),
2285           INFO_LDAP_EXT_SERVER_DESC_BIND_RELEASED_VALID.get(),
2286           bindPoolNumReleasedValid);
2287    }
2288
2289    if (nonBindPoolAvailableConnections != null)
2290    {
2291      addMonitorAttribute(attrs,
2292           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_AVAILABLE_CONNS,
2293           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_AVAILABLE_CONNS.get(),
2294           INFO_LDAP_EXT_SERVER_DESC_NONBIND_AVAILABLE_CONNS.get(),
2295           nonBindPoolAvailableConnections);
2296    }
2297
2298    if (nonBindPoolMaxAvailableConnections != null)
2299    {
2300      addMonitorAttribute(attrs,
2301           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_MAX_AVAILABLE_CONNS,
2302           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_MAX_AVAILABLE_CONNS.get(),
2303           INFO_LDAP_EXT_SERVER_DESC_NONBIND_MAX_AVAILABLE_CONNS.get(),
2304           nonBindPoolMaxAvailableConnections);
2305    }
2306
2307    if (nonBindPoolNumSuccessfulConnectionAttempts != null)
2308    {
2309      addMonitorAttribute(attrs,
2310           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS,
2311           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CONNECT_SUCCESS.get(),
2312           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CONNECT_SUCCESS.get(),
2313           nonBindPoolNumSuccessfulConnectionAttempts);
2314    }
2315
2316    if (nonBindPoolNumFailedConnectionAttempts != null)
2317    {
2318      addMonitorAttribute(attrs,
2319           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_FAILED_CONNECTS,
2320           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CONNECT_FAILED.get(),
2321           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CONNECT_FAILED.get(),
2322           nonBindPoolNumFailedConnectionAttempts);
2323    }
2324
2325    if (nonBindPoolNumClosedDefunct != null)
2326    {
2327      addMonitorAttribute(attrs,
2328           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_CLOSED_DEFUNCT,
2329           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CLOSED_DEFUNCT.get(),
2330           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CLOSED_DEFUNCT.get(),
2331           nonBindPoolNumClosedDefunct);
2332    }
2333
2334    if (nonBindPoolNumClosedExpired != null)
2335    {
2336      addMonitorAttribute(attrs,
2337           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_CLOSED_EXPIRED,
2338           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CLOSED_EXPIRED.get(),
2339           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CLOSED_EXPIRED.get(),
2340           nonBindPoolNumClosedExpired);
2341    }
2342
2343    if (nonBindPoolNumClosedUnneeded != null)
2344    {
2345      addMonitorAttribute(attrs,
2346           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_CLOSED_UNNEEDED,
2347           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CLOSED_UNNEEDED.get(),
2348           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CLOSED_UNNEEDED.get(),
2349           nonBindPoolNumClosedUnneeded);
2350    }
2351
2352    if (nonBindPoolNumSuccessfulCheckouts != null)
2353    {
2354      addMonitorAttribute(attrs,
2355           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS,
2356           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_SUCCESS.get(),
2357           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_SUCCESS.get(),
2358           nonBindPoolNumSuccessfulCheckouts);
2359    }
2360
2361    if (nonBindPoolNumSuccessfulCheckoutsWithoutWaiting != null)
2362    {
2363      addMonitorAttribute(attrs,
2364           ATTR_PREFIX_NONBIND_POOL +
2365                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING,
2366           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_NO_WAIT.get(),
2367           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_NO_WAIT.get(),
2368           nonBindPoolNumSuccessfulCheckoutsWithoutWaiting);
2369    }
2370
2371    if (nonBindPoolNumSuccessfulCheckoutsAfterWaiting != null)
2372    {
2373      addMonitorAttribute(attrs,
2374           ATTR_PREFIX_NONBIND_POOL +
2375                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING,
2376           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_WITH_WAIT.get(),
2377           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_WITH_WAIT.get(),
2378           nonBindPoolNumSuccessfulCheckoutsAfterWaiting);
2379    }
2380
2381    if (nonBindPoolNumSuccessfulCheckoutsNewConnection != null)
2382    {
2383      addMonitorAttribute(attrs,
2384           ATTR_PREFIX_NONBIND_POOL +
2385                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN,
2386           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_NEW_CONN.get(),
2387           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_NEW_CONN.get(),
2388           nonBindPoolNumSuccessfulCheckoutsNewConnection);
2389    }
2390
2391    if (nonBindPoolNumFailedCheckouts != null)
2392    {
2393      addMonitorAttribute(attrs,
2394           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_FAILED_CHECKOUTS,
2395           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_FAILED.get(),
2396           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_FAILED.get(),
2397           nonBindPoolNumFailedCheckouts);
2398    }
2399
2400    if (nonBindPoolNumReleasedValid != null)
2401    {
2402      addMonitorAttribute(attrs,
2403           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_RELEASED_VALID,
2404           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_RELEASED_VALID.get(),
2405           INFO_LDAP_EXT_SERVER_DESC_NONBIND_RELEASED_VALID.get(),
2406           nonBindPoolNumReleasedValid);
2407    }
2408
2409    if (addAttempts != null)
2410    {
2411      addMonitorAttribute(attrs,
2412           ATTR_ADD_ATTEMPTS,
2413           INFO_LDAP_EXT_SERVER_DISPNAME_ADD_ATTEMPTS.get(),
2414           INFO_LDAP_EXT_SERVER_DESC_ADD_ATTEMPTS.get(),
2415           addAttempts);
2416    }
2417
2418    if (addFailures != null)
2419    {
2420      addMonitorAttribute(attrs,
2421           ATTR_ADD_FAILURES,
2422           INFO_LDAP_EXT_SERVER_DISPNAME_ADD_FAILURES.get(),
2423           INFO_LDAP_EXT_SERVER_DESC_ADD_FAILURES.get(),
2424           addFailures);
2425    }
2426
2427    if (addSuccesses != null)
2428    {
2429      addMonitorAttribute(attrs,
2430           ATTR_ADD_SUCCESSES,
2431           INFO_LDAP_EXT_SERVER_DISPNAME_ADD_SUCCESSES.get(),
2432           INFO_LDAP_EXT_SERVER_DESC_ADD_SUCCESSES.get(),
2433           addSuccesses);
2434    }
2435
2436    if (bindAttempts != null)
2437    {
2438      addMonitorAttribute(attrs,
2439           ATTR_BIND_ATTEMPTS,
2440           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_ATTEMPTS.get(),
2441           INFO_LDAP_EXT_SERVER_DESC_BIND_ATTEMPTS.get(),
2442           bindAttempts);
2443    }
2444
2445    if (bindFailures != null)
2446    {
2447      addMonitorAttribute(attrs,
2448           ATTR_BIND_FAILURES,
2449           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_FAILURES.get(),
2450           INFO_LDAP_EXT_SERVER_DESC_BIND_FAILURES.get(),
2451           bindFailures);
2452    }
2453
2454    if (bindSuccesses != null)
2455    {
2456      addMonitorAttribute(attrs,
2457           ATTR_BIND_SUCCESSES,
2458           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_SUCCESSES.get(),
2459           INFO_LDAP_EXT_SERVER_DESC_BIND_SUCCESSES.get(),
2460           bindSuccesses);
2461    }
2462
2463    if (compareAttempts != null)
2464    {
2465      addMonitorAttribute(attrs,
2466           ATTR_COMPARE_ATTEMPTS,
2467           INFO_LDAP_EXT_SERVER_DISPNAME_COMPARE_ATTEMPTS.get(),
2468           INFO_LDAP_EXT_SERVER_DESC_COMPARE_ATTEMPTS.get(),
2469           compareAttempts);
2470    }
2471
2472    if (compareFailures != null)
2473    {
2474      addMonitorAttribute(attrs,
2475           ATTR_COMPARE_FAILURES,
2476           INFO_LDAP_EXT_SERVER_DISPNAME_COMPARE_FAILURES.get(),
2477           INFO_LDAP_EXT_SERVER_DESC_COMPARE_FAILURES.get(),
2478           compareFailures);
2479    }
2480
2481    if (compareSuccesses != null)
2482    {
2483      addMonitorAttribute(attrs,
2484           ATTR_COMPARE_SUCCESSES,
2485           INFO_LDAP_EXT_SERVER_DISPNAME_COMPARE_SUCCESSES.get(),
2486           INFO_LDAP_EXT_SERVER_DESC_COMPARE_SUCCESSES.get(),
2487           compareSuccesses);
2488    }
2489
2490    if (deleteAttempts != null)
2491    {
2492      addMonitorAttribute(attrs,
2493           ATTR_DELETE_ATTEMPTS,
2494           INFO_LDAP_EXT_SERVER_DISPNAME_DELETE_ATTEMPTS.get(),
2495           INFO_LDAP_EXT_SERVER_DESC_DELETE_ATTEMPTS.get(),
2496           deleteAttempts);
2497    }
2498
2499    if (deleteFailures != null)
2500    {
2501      addMonitorAttribute(attrs,
2502           ATTR_DELETE_FAILURES,
2503           INFO_LDAP_EXT_SERVER_DISPNAME_DELETE_FAILURES.get(),
2504           INFO_LDAP_EXT_SERVER_DESC_DELETE_FAILURES.get(),
2505           deleteFailures);
2506    }
2507
2508    if (deleteSuccesses != null)
2509    {
2510      addMonitorAttribute(attrs,
2511           ATTR_DELETE_SUCCESSES,
2512           INFO_LDAP_EXT_SERVER_DISPNAME_DELETE_SUCCESSES.get(),
2513           INFO_LDAP_EXT_SERVER_DESC_DELETE_SUCCESSES.get(),
2514           deleteSuccesses);
2515    }
2516
2517    if (modifyAttempts != null)
2518    {
2519      addMonitorAttribute(attrs,
2520           ATTR_MODIFY_ATTEMPTS,
2521           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_ATTEMPTS.get(),
2522           INFO_LDAP_EXT_SERVER_DESC_MODIFY_ATTEMPTS.get(),
2523           modifyAttempts);
2524    }
2525
2526    if (modifyFailures != null)
2527    {
2528      addMonitorAttribute(attrs,
2529           ATTR_MODIFY_FAILURES,
2530           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_FAILURES.get(),
2531           INFO_LDAP_EXT_SERVER_DESC_MODIFY_FAILURES.get(),
2532           modifyFailures);
2533    }
2534
2535    if (modifySuccesses != null)
2536    {
2537      addMonitorAttribute(attrs,
2538           ATTR_MODIFY_SUCCESSES,
2539           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_SUCCESSES.get(),
2540           INFO_LDAP_EXT_SERVER_DESC_MODIFY_SUCCESSES.get(),
2541           modifySuccesses);
2542    }
2543
2544    if (modifyDNAttempts != null)
2545    {
2546      addMonitorAttribute(attrs,
2547           ATTR_MODIFY_DN_ATTEMPTS,
2548           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_DN_ATTEMPTS.get(),
2549           INFO_LDAP_EXT_SERVER_DESC_MODIFY_DN_ATTEMPTS.get(),
2550           modifyDNAttempts);
2551    }
2552
2553    if (modifyDNFailures != null)
2554    {
2555      addMonitorAttribute(attrs,
2556           ATTR_MODIFY_DN_FAILURES,
2557           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_DN_FAILURES.get(),
2558           INFO_LDAP_EXT_SERVER_DESC_MODIFY_DN_FAILURES.get(),
2559           modifyDNFailures);
2560    }
2561
2562    if (modifyDNSuccesses != null)
2563    {
2564      addMonitorAttribute(attrs,
2565           ATTR_MODIFY_DN_SUCCESSES,
2566           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_DN_SUCCESSES.get(),
2567           INFO_LDAP_EXT_SERVER_DESC_MODIFY_DN_SUCCESSES.get(),
2568           modifyDNSuccesses);
2569    }
2570
2571    if (searchAttempts != null)
2572    {
2573      addMonitorAttribute(attrs,
2574           ATTR_SEARCH_ATTEMPTS,
2575           INFO_LDAP_EXT_SERVER_DISPNAME_SEARCH_ATTEMPTS.get(),
2576           INFO_LDAP_EXT_SERVER_DESC_SEARCH_ATTEMPTS.get(),
2577           searchAttempts);
2578    }
2579
2580    if (searchFailures != null)
2581    {
2582      addMonitorAttribute(attrs,
2583           ATTR_SEARCH_FAILURES,
2584           INFO_LDAP_EXT_SERVER_DISPNAME_SEARCH_FAILURES.get(),
2585           INFO_LDAP_EXT_SERVER_DESC_SEARCH_FAILURES.get(),
2586           searchFailures);
2587    }
2588
2589    if (searchSuccesses != null)
2590    {
2591      addMonitorAttribute(attrs,
2592           ATTR_SEARCH_SUCCESSES,
2593           INFO_LDAP_EXT_SERVER_DISPNAME_SEARCH_SUCCESSES.get(),
2594           INFO_LDAP_EXT_SERVER_DESC_SEARCH_SUCCESSES.get(),
2595           searchSuccesses);
2596    }
2597
2598    return Collections.unmodifiableMap(attrs);
2599  }
2600}