001 /* 002 * Copyright 2008-2015 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005 /* 006 * Copyright (C) 2015 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021 package com.unboundid.ldap.sdk.unboundidds.monitors; 022 023 024 025 import java.util.ArrayList; 026 import java.util.Collections; 027 import java.util.Date; 028 import java.util.LinkedHashMap; 029 import java.util.Map; 030 031 import com.unboundid.ldap.sdk.Attribute; 032 import com.unboundid.ldap.sdk.Entry; 033 import com.unboundid.util.NotMutable; 034 import com.unboundid.util.ThreadSafety; 035 import com.unboundid.util.ThreadSafetyLevel; 036 037 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 038 import static com.unboundid.util.StaticUtils.*; 039 040 041 042 /** 043 * <BLOCKQUOTE> 044 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 045 * LDAP SDK for Java. It is not available for use in applications that 046 * include only the Standard Edition of the LDAP SDK, and is not supported for 047 * use in conjunction with non-UnboundID products. 048 * </BLOCKQUOTE> 049 * This class defines a monitor entry that provides basic information about the 050 * Berkeley DB Java Edition environment in use for a backend. The information 051 * that is provided includes: 052 * <UL> 053 * <LI>The backend ID for the associated backend.</LI> 054 * <LI>The version string for the Berkeley DB Java Edition library.</LI> 055 * <LI>The path to the directory containing the database environment 056 * files.</LI> 057 * <LI>The amount of space consumed by the database files.</LI> 058 * <LI>The amount of memory currently consumed by the database cache.</LI> 059 * <LI>The maximum amount of memory that may be consumed by the database 060 * cache.</LI> 061 * <LI>The percent of the total memory allowed for the database cache that is 062 * currently in use.</LI> 063 * <LI>Whether a checkpoint is currently in progress.</LI> 064 * <LI>The total number of checkpoints that have been completed.</LI> 065 * <LI>The time that the last completed checkpoint began.</LI> 066 * <LI>The time that the last completed checkpoint ended.</LI> 067 * <LI>The total duration of all checkpoints completed.</LI> 068 * <LI>The average duration of all checkpoints completed.</LI> 069 * <LI>The duration of the last checkpoint completed.</LI> 070 * <LI>The length of time since the last checkpoint.</LI> 071 * <LI>The number of log files that the cleaner needs to examine.</LI> 072 * <LI>The number of nodes evicted from the database cache.</LI> 073 * <LI>The number of random-access disk reads performed.</LI> 074 * <LI>The number of random-access disk writes performed.</LI> 075 * <LI>The number of sequential disk reads performed.</LI> 076 * <LI>The number of sequential disk writes performed.</LI> 077 * <LI>The number of active transactions in the database environment.</LI> 078 * <LI>The number of read locks held in the database environment.</LI> 079 * <LI>The number of write locks held in the database environment.</LI> 080 * <LI>The number of transactions waiting on locks.</LI> 081 * <LI>A set of generic statistics about the database environment.</LI> 082 * <LI>A set of generic statistics about the lock subsystem for the database 083 * environment.</LI> 084 * <LI>A set of generic statistics about the transaction subsystem for the 085 * database environment.</LI> 086 * </UL> 087 * The JE environment monitor entries provided by the server can be 088 * retrieved using the {@link MonitorManager#getJEEnvironmentMonitorEntries} 089 * method. These entries provide specific methods for accessing information 090 * about the JE environment (e.g., the 091 * {@link JEEnvironmentMonitorEntry#getJEVersion} method can be used to retrieve 092 * the Berkeley DB JE version). Alternately, this information may be accessed 093 * using the generic API. See the {@link MonitorManager} class documentation 094 * for an example that demonstrates the use of the generic API for accessing 095 * monitor data. 096 */ 097 @NotMutable() 098 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 099 public final class JEEnvironmentMonitorEntry 100 extends MonitorEntry 101 { 102 /** 103 * The structural object class used in JE environment monitor entries. 104 */ 105 static final String JE_ENVIRONMENT_MONITOR_OC = 106 "ds-je-environment-monitor-entry"; 107 108 109 110 /** 111 * The name of the attribute that contains the number of active transactions. 112 */ 113 private static final String ATTR_ACTIVE_TXNS = "active-transaction-count"; 114 115 116 117 /** 118 * The name of the attribute that contains the average duration of the all 119 * checkpoints in milliseconds. 120 */ 121 private static final String ATTR_AVERAGE_CHECKPOINT_DURATION_MILLIS = 122 "average-checkpoint-duration-millis"; 123 124 125 126 /** 127 * The name of the attribute that contains the backend ID for the associated 128 * backend. 129 */ 130 private static final String ATTR_BACKEND_ID = "backend-id"; 131 132 133 134 /** 135 * The name of the attribute that contains the DB cache percent full. 136 */ 137 private static final String ATTR_CACHE_PCT_FULL = "db-cache-percent-full"; 138 139 140 141 /** 142 * The name of the attribute that indicates whether a checkpoint is currently 143 * in progress. 144 */ 145 private static final String ATTR_CHECKPOINT_IN_PROGRESS = 146 "checkpoint-in-progress"; 147 148 149 150 /** 151 * The name of the attribute that contains the cleaner backlog. 152 */ 153 private static final String ATTR_CLEANER_BACKLOG = "cleaner-backlog"; 154 155 156 157 /** 158 * The name of the attribute that contains the current DB cache size. 159 */ 160 private static final String ATTR_CURRENT_CACHE_SIZE = "current-db-cache-size"; 161 162 163 164 /** 165 * The name of the attribute that contains the path to the DB directory. 166 */ 167 private static final String ATTR_DB_DIRECTORY = "db-directory"; 168 169 170 171 /** 172 * The name of the attribute that contains the DB on-disk size. 173 */ 174 private static final String ATTR_DB_ON_DISK_SIZE = "db-on-disk-size"; 175 176 177 178 /** 179 * The name of the attribute that contains the Berkeley DB JE version string. 180 */ 181 private static final String ATTR_JE_VERSION = "je-version"; 182 183 184 185 /** 186 * The name of the attribute that contains the duration of the last checkpoint 187 * in milliseconds. 188 */ 189 private static final String ATTR_LAST_CHECKPOINT_DURATION_MILLIS = 190 "last-checkpoint-duration-millis"; 191 192 193 194 /** 195 * The name of the attribute that contains the time the last checkpoint began. 196 */ 197 private static final String ATTR_LAST_CHECKPOINT_START_TIME = 198 "last-checkpoint-start-time"; 199 200 201 202 /** 203 * The name of the attribute that contains the time the last checkpoint ended. 204 */ 205 private static final String ATTR_LAST_CHECKPOINT_STOP_TIME = 206 "last-checkpoint-stop-time"; 207 208 209 210 /** 211 * The name of the attribute that contains the time of the last checkpoint. 212 * 213 * @deprecated Use {@link #ATTR_LAST_CHECKPOINT_STOP_TIME} instead. 214 */ 215 @Deprecated() 216 private static final String ATTR_LAST_CHECKPOINT_TIME = 217 "last-checkpoint-time"; 218 219 220 221 /** 222 * The name of the attribute that contains the maximum cache size. 223 */ 224 private static final String ATTR_MAX_CACHE_SIZE = "max-db-cache-size"; 225 226 227 228 /** 229 * The name of the attribute that contains the length of time in milliseconds 230 * since the last checkpoint. 231 */ 232 private static final String ATTR_MILLIS_SINCE_LAST_CHECKPOINT = 233 "millis-since-last-checkpoint"; 234 235 236 237 /** 238 * The name of the attribute that contains the number of nodes evicted from 239 * the cache. 240 */ 241 private static final String ATTR_NODES_EVICTED = "nodes-evicted"; 242 243 244 245 /** 246 * The name of the attribute that contains the number of checkpoints 247 * processed. 248 */ 249 private static final String ATTR_NUM_CHECKPOINTS = "num-checkpoints"; 250 251 252 253 /** 254 * The name of the attribute that contains the number of read locks held. 255 */ 256 private static final String ATTR_NUM_READ_LOCKS = "read-locks-held"; 257 258 259 260 /** 261 * The name of the attribute that contains the total duration of the all 262 * checkpoints in milliseconds. 263 */ 264 private static final String ATTR_TOTAL_CHECKPOINT_DURATION_MILLIS = 265 "total-checkpoint-duration-millis"; 266 267 268 269 /** 270 * The name of the attribute that contains the number of transactions waiting 271 * on locks. 272 */ 273 private static final String ATTR_NUM_WAITING_TXNS = 274 "transactions-waiting-on-locks"; 275 276 277 278 /** 279 * The name of the attribute that contains the number of write locks held. 280 */ 281 private static final String ATTR_NUM_WRITE_LOCKS = "write-locks-held"; 282 283 284 285 /** 286 * The name of the attribute that contains the number of random reads. 287 */ 288 private static final String ATTR_RANDOM_READS = "random-read-count"; 289 290 291 292 /** 293 * The name of the attribute that contains the number of random writes. 294 */ 295 private static final String ATTR_RANDOM_WRITES = "random-write-count"; 296 297 298 299 /** 300 * The name of the attribute that contains the number of sequential reads. 301 */ 302 private static final String ATTR_SEQUENTIAL_READS = "sequential-read-count"; 303 304 305 306 /** 307 * The name of the attribute that contains the number of sequential writes. 308 */ 309 private static final String ATTR_SEQUENTIAL_WRITES = "sequential-write-count"; 310 311 312 313 /** 314 * The prefix that will be used for attribute names that contain generic 315 * environment statistics. 316 */ 317 private static final String ATTR_PREFIX_ENV_STAT = "je-env-stat-"; 318 319 320 321 /** 322 * The prefix that will be used for attribute names that contain generic lock 323 * statistics. 324 */ 325 private static final String ATTR_PREFIX_LOCK_STAT = "je-lock-stat-"; 326 327 328 329 /** 330 * The prefix that will be used for attribute names that contain generic 331 * transaction statistics. 332 */ 333 private static final String ATTR_PREFIX_TXN_STAT = "je-txn-stat-"; 334 335 336 337 /** 338 * The name that will be used for the property that contains generic 339 * environment statistics. 340 */ 341 private static final String PROPERTY_ENV_STATS = "je-env-stats"; 342 343 344 345 /** 346 * The name that will be used for the property that contains generic lock 347 * statistics. 348 */ 349 private static final String PROPERTY_LOCK_STATS = "je-lock-stats"; 350 351 352 353 /** 354 * The name that will be used for the property that contains generic 355 * transaction statistics. 356 */ 357 private static final String PROPERTY_TXN_STATS = "je-txn-stats"; 358 359 360 361 /** 362 * The serial version UID for this serializable class. 363 */ 364 private static final long serialVersionUID = 2557783119454069632L; 365 366 367 368 // Indicates whether a checkpoint is currently in progress. 369 private final Boolean checkpointInProgress; 370 371 // The time the last checkpoint began. 372 private final Date lastCheckpointStartTime; 373 374 // The time the last checkpoint ended. 375 private final Date lastCheckpointStopTime; 376 377 // The time the last checkpoint ended. 378 @Deprecated 379 private final Date lastCheckpointTime; 380 381 // The number of active transactions. 382 private final Long activeTransactionCount; 383 384 // The average duration for all checkpoints. 385 private final Long averageCheckpointDurationMillis; 386 387 // The current cleaner backlog. 388 private final Long cleanerBacklog; 389 390 // The current DB cache size. 391 private final Long currentDBCacheSize; 392 393 // The current DB cache percent full. 394 private final Long dbCachePercentFull; 395 396 // The current DB on-disk size. 397 private final Long dbOnDiskSize; 398 399 // The duration for the last checkpoint. 400 private final Long lastCheckpointDurationMillis; 401 402 // The maximum allowed DB cache size. 403 private final Long maxDBCacheSize; 404 405 // The length of time since the last checkpoint. 406 private final Long millisSinceLastCheckpoint; 407 408 // The number of nodes evicted from the DB cache. 409 private final Long nodesEvicted; 410 411 // The number of checkpoints completed. 412 private final Long numCheckpoints; 413 414 // The number of random reads performed. 415 private final Long randomReads; 416 417 // The number of random writes performed. 418 private final Long randomWrites; 419 420 // The number of read locks held. 421 private final Long readLocksHeld; 422 423 // The number of sequential reads performed. 424 private final Long sequentialReads; 425 426 // The number of sequential writes performed. 427 private final Long sequentialWrites; 428 429 // The total duration for all checkpoints. 430 private final Long totalCheckpointDurationMillis; 431 432 // The number of transactions waiting on locks. 433 private final Long transactionsWaitingOnLocks; 434 435 // The number of write locks held. 436 private final Long writeLocksHeld; 437 438 // The set of generic environment statistics. 439 private final Map<String,String> envStats; 440 441 // The set of generic lock statistics. 442 private final Map<String,String> lockStats; 443 444 // The set of generic transaction statistics. 445 private final Map<String,String> txnStats; 446 447 // The backend ID for the associated backend. 448 private final String backendID; 449 450 // The path to the directory containing the database files. 451 private final String dbDirectory; 452 453 // The Berkeley DB JE version string. 454 private final String jeVersion; 455 456 457 458 /** 459 * Creates a new JE environment monitor entry from the provided entry. 460 * 461 * @param entry The entry to be parsed as a JE environment monitor entry. 462 * It must not be {@code null}. 463 */ 464 @SuppressWarnings("deprecation") 465 public JEEnvironmentMonitorEntry(final Entry entry) 466 { 467 super(entry); 468 469 activeTransactionCount = getLong(ATTR_ACTIVE_TXNS); 470 cleanerBacklog = getLong(ATTR_CLEANER_BACKLOG); 471 currentDBCacheSize = getLong(ATTR_CURRENT_CACHE_SIZE); 472 dbCachePercentFull = getLong(ATTR_CACHE_PCT_FULL); 473 dbOnDiskSize = getLong(ATTR_DB_ON_DISK_SIZE); 474 maxDBCacheSize = getLong(ATTR_MAX_CACHE_SIZE); 475 nodesEvicted = getLong(ATTR_NODES_EVICTED); 476 randomReads = getLong(ATTR_RANDOM_READS); 477 randomWrites = getLong(ATTR_RANDOM_WRITES); 478 readLocksHeld = getLong(ATTR_NUM_READ_LOCKS); 479 sequentialReads = getLong(ATTR_SEQUENTIAL_READS); 480 sequentialWrites = getLong(ATTR_SEQUENTIAL_WRITES); 481 transactionsWaitingOnLocks = getLong(ATTR_NUM_WAITING_TXNS); 482 writeLocksHeld = getLong(ATTR_NUM_WRITE_LOCKS); 483 backendID = getString(ATTR_BACKEND_ID); 484 dbDirectory = getString(ATTR_DB_DIRECTORY); 485 jeVersion = getString(ATTR_JE_VERSION); 486 487 checkpointInProgress = getBoolean(ATTR_CHECKPOINT_IN_PROGRESS); 488 lastCheckpointStartTime = getDate(ATTR_LAST_CHECKPOINT_START_TIME); 489 lastCheckpointStopTime = getDate(ATTR_LAST_CHECKPOINT_STOP_TIME); 490 lastCheckpointTime = getDate(ATTR_LAST_CHECKPOINT_TIME); 491 averageCheckpointDurationMillis = 492 getLong(ATTR_AVERAGE_CHECKPOINT_DURATION_MILLIS); 493 lastCheckpointDurationMillis = 494 getLong(ATTR_LAST_CHECKPOINT_DURATION_MILLIS); 495 millisSinceLastCheckpoint = getLong(ATTR_MILLIS_SINCE_LAST_CHECKPOINT); 496 numCheckpoints = getLong(ATTR_NUM_CHECKPOINTS); 497 totalCheckpointDurationMillis = 498 getLong(ATTR_TOTAL_CHECKPOINT_DURATION_MILLIS); 499 500 final LinkedHashMap<String,String> tmpEnvStats = 501 new LinkedHashMap<String,String>(); 502 final LinkedHashMap<String,String> tmpLockStats = 503 new LinkedHashMap<String,String>(); 504 final LinkedHashMap<String,String> tmpTxnStats = 505 new LinkedHashMap<String,String>(); 506 for (final Attribute a : entry.getAttributes()) 507 { 508 final String name = toLowerCase(a.getName()); 509 if (name.startsWith(ATTR_PREFIX_ENV_STAT)) 510 { 511 tmpEnvStats.put( 512 toLowerCase(name.substring(ATTR_PREFIX_ENV_STAT.length())), 513 a.getValue()); 514 } 515 else if (name.startsWith(ATTR_PREFIX_LOCK_STAT)) 516 { 517 tmpLockStats.put( 518 toLowerCase(name.substring(ATTR_PREFIX_LOCK_STAT.length())), 519 a.getValue()); 520 } 521 else if (name.startsWith(ATTR_PREFIX_TXN_STAT)) 522 { 523 tmpTxnStats.put( 524 toLowerCase(name.substring(ATTR_PREFIX_TXN_STAT.length())), 525 a.getValue()); 526 } 527 } 528 529 envStats = Collections.unmodifiableMap(tmpEnvStats); 530 lockStats = Collections.unmodifiableMap(tmpLockStats); 531 txnStats = Collections.unmodifiableMap(tmpTxnStats); 532 } 533 534 535 536 /** 537 * Retrieves the backend ID for the backend with which the Berkeley DB JE 538 * database is associated. 539 * 540 * @return The backend ID for the backend with which the Berkeley DB JE 541 * database is associated. 542 */ 543 public String getBackendID() 544 { 545 return backendID; 546 } 547 548 549 550 /** 551 * Retrieves the Berkeley DB JE version string for the database environment 552 * of the associated backend. 553 * 554 * @return The Berkeley DB JE version string for the database environment of 555 * the associated backend, or {@code null} if it was not included in 556 * the monitor entry. 557 */ 558 public String getJEVersion() 559 { 560 return jeVersion; 561 } 562 563 564 565 /** 566 * Retrieves the path to the directory containing the database files. 567 * 568 * @return The path to the directory containing the database files, or 569 * {@code null} if it was not included in the monitor entry. 570 */ 571 public String getDBDirectory() 572 { 573 return dbDirectory; 574 } 575 576 577 578 /** 579 * Retrieves the amount of disk space in bytes consumed by the database files. 580 * 581 * @return The amount of disk space in bytes consumed by the database files, 582 * or {@code null} if it was not included in the monitor entry. 583 */ 584 public Long getDBOnDiskSize() 585 { 586 return dbOnDiskSize; 587 } 588 589 590 591 /** 592 * Retrieves the amount of memory in bytes currently consumed by the database 593 * cache. 594 * 595 * @return The amount of memory in bytes currently consumed by the database 596 * cache, or {@code null} if it was not included in the monitor 597 * entry. 598 */ 599 public Long getCurrentDBCacheSize() 600 { 601 return currentDBCacheSize; 602 } 603 604 605 606 /** 607 * Retrieves the maximum amount of memory in bytes that may be consumed by the 608 * database cache. 609 * 610 * @return The maximum of memory in bytes that may be consumed by the 611 * database cache, or {@code null} if it was not included in the 612 * monitor entry. 613 */ 614 public Long getMaxDBCacheSize() 615 { 616 return maxDBCacheSize; 617 } 618 619 620 621 /** 622 * Retrieves the percentage of the maximum database cache size that is 623 * currently in use. 624 * 625 * @return The percentage of the maximum database cache size that is 626 * currently in use, or {@code null} if it was not included in the 627 * monitor entry. 628 */ 629 public Long getDBCachePercentFull() 630 { 631 return dbCachePercentFull; 632 } 633 634 635 636 /** 637 * Indicates whether a checkpoint is currently in progress in the associated 638 * backend. 639 * 640 * @return A {@code Boolean} value indicating whether a checkpoint is 641 * currently in progress in the associated backend, or {@code null} 642 * if it was not included in the monitor entry. 643 */ 644 public Boolean checkpointInProgress() 645 { 646 return checkpointInProgress; 647 } 648 649 650 651 /** 652 * Retrieves the number of checkpoints completed in the associated backend. 653 * 654 * @return The number of checkpoints completed in the associated backend, or 655 * {@code null} if it was not included in the monitor entry. 656 */ 657 public Long getNumCheckpoints() 658 { 659 return numCheckpoints; 660 } 661 662 663 664 /** 665 * Retrieves the total duration in milliseconds of all checkpoints completed 666 * in the associated backend. 667 * 668 * @return The total duration in milliseconds of all checkpoints completed in 669 * the associated backend, or {@code null} if it was not included in 670 * the monitor entry. 671 */ 672 public Long getTotalCheckpointDurationMillis() 673 { 674 return totalCheckpointDurationMillis; 675 } 676 677 678 679 /** 680 * Retrieves the average duration in milliseconds of all checkpoints completed 681 * in the associated backend. 682 * 683 * @return The average duration in milliseconds of all checkpoints completed 684 * in the associated backend, or {@code null} if it was not included 685 * in the monitor entry. 686 */ 687 public Long getAverageCheckpointDurationMillis() 688 { 689 return averageCheckpointDurationMillis; 690 } 691 692 693 694 /** 695 * Retrieves the duration in milliseconds of the last checkpoint completed in 696 * the associated backend. 697 * 698 * @return The duration in milliseconds of the last checkpoint completed in 699 * the associated backend, or {@code null} if it was not included 700 * in the monitor entry. 701 */ 702 public Long getLastCheckpointDurationMillis() 703 { 704 return lastCheckpointDurationMillis; 705 } 706 707 708 709 /** 710 * Retrieves the time that the last completed checkpoint began. 711 * 712 * @return The time that the last completed checkpoint began, or {@code null} 713 * if it was not included in the monitor entry. 714 */ 715 public Date getLastCheckpointStartTime() 716 { 717 return lastCheckpointStartTime; 718 } 719 720 721 722 /** 723 * Retrieves the time that the last completed checkpoint ended. 724 * 725 * @return The time that the last completed checkpoint ended, or {@code null} 726 * if it was not included in the monitor entry. 727 */ 728 public Date getLastCheckpointStopTime() 729 { 730 return lastCheckpointStopTime; 731 } 732 733 734 735 /** 736 * Retrieves the time that the last checkpoint occurred. 737 * 738 * @return The time that the last checkpoint occurred, or {@code null} if it 739 * was not included in the monitor entry. 740 * 741 * @deprecated Use {@link #getLastCheckpointStopTime()} instead. 742 */ 743 @Deprecated() 744 @SuppressWarnings("deprecation") 745 public Date getLastCheckpointTime() 746 { 747 return lastCheckpointTime; 748 } 749 750 751 752 /** 753 * Retrieves the length of time in milliseconds since the last completed 754 * checkpoint. 755 * 756 * @return The length of time in milliseconds since the last completed 757 * checkpoint, or {@code null} if it was not included in the monitor 758 * entry. 759 */ 760 public Long getMillisSinceLastCheckpoint() 761 { 762 return millisSinceLastCheckpoint; 763 } 764 765 766 767 /** 768 * Retrieves the number of log files that the cleaner needs to examine. 769 * 770 * @return The number of log files that the cleaner needs to examine, or 771 * {@code null} if it was not included in the monitor entry. 772 */ 773 public Long getCleanerBacklog() 774 { 775 return cleanerBacklog; 776 } 777 778 779 780 /** 781 * Retrieves the number of nodes that have been evicted from the database 782 * cache since the backend was started. 783 * 784 * @return The number of nodes that have been evicted from the database cache 785 * since the backend was started, or {@code null} if it was not 786 * included in the monitor entry. 787 */ 788 public Long getNodesEvicted() 789 { 790 return nodesEvicted; 791 } 792 793 794 795 /** 796 * Retrieves the number of random-access disk reads performed since the 797 * backend was started. 798 * 799 * @return The number of random-access disk reads performed since the backend 800 * was started, or {@code null} if it was not included in the monitor 801 * entry. 802 */ 803 public Long getRandomReads() 804 { 805 return randomReads; 806 } 807 808 809 810 /** 811 * Retrieves the number of random-access disk writes performed since the 812 * backend was started. 813 * 814 * @return The number of random-access disk writes performed since the 815 * backend was started, or {@code null} if it was not included in the 816 * monitor entry. 817 */ 818 public Long getRandomWrites() 819 { 820 return randomWrites; 821 } 822 823 824 825 /** 826 * Retrieves the number of sequential disk reads performed since the backend 827 * was started. 828 * 829 * @return The number of sequential disk reads performed since the backend 830 * was started, or {@code null} if it was not included in the monitor 831 * entry. 832 */ 833 public Long getSequentialReads() 834 { 835 return sequentialReads; 836 } 837 838 839 840 /** 841 * Retrieves the number of sequential disk writes performed since the backend 842 * was started. 843 * 844 * @return The number of sequential disk writes performed since the backend 845 * was started, or {@code null} if it was not included in the monitor 846 * entry. 847 */ 848 public Long getSequentialWrites() 849 { 850 return sequentialWrites; 851 } 852 853 854 855 /** 856 * Retrieves the number of active transactions in the JE database environment. 857 * 858 * @return The number of active transactions in the JE database environment, 859 * or {@code null} if it was not included in the monitor entry. 860 */ 861 public Long getActiveTransactionCount() 862 { 863 return activeTransactionCount; 864 } 865 866 867 868 /** 869 * Retrieves the number of read locks held in the JE database environment. 870 * 871 * @return The number of read locks held in the JE database environment, or 872 * {@code null} if it was not included in the monitor entry. 873 */ 874 public Long getReadLocksHeld() 875 { 876 return readLocksHeld; 877 } 878 879 880 881 /** 882 * Retrieves the number of write locks held in the JE database environment. 883 * 884 * @return The number of write locks held in the JE database environment, or 885 * {@code null} if it was not included in the monitor entry. 886 */ 887 public Long getWriteLocksHeld() 888 { 889 return writeLocksHeld; 890 } 891 892 893 894 /** 895 * Retrieves the number of transactions currently waiting on a lock in the 896 * database environment. 897 * 898 * @return The number of transactions currently waiting on a lock in the 899 * database environment, or {@code null} if it was not included in 900 * the monitor entry. 901 */ 902 public Long getTransactionsWaitingOnLocks() 903 { 904 return transactionsWaitingOnLocks; 905 } 906 907 908 909 /** 910 * Retrieves a set of general environment statistics for the database 911 * environment, mapped from the statistic name to the string representation of 912 * its value. The statistic names will be formatted in all lowercase 913 * characters. 914 * 915 * @return A set of general environment statistics for the database 916 * environment, mapped from the statistic name to the string 917 * representation of its value. 918 */ 919 public Map<String,String> getEnvironmentStats() 920 { 921 return envStats; 922 } 923 924 925 926 /** 927 * Retrieves the string representation of the value for a database environment 928 * statistic. 929 * 930 * @param statName The name of the statistic to retrieve. It will be 931 * treated in a case-insensitive manner. 932 * 933 * @return The value of the requested database environment statistic, or 934 * {@code null} if no such statistic was provided. 935 */ 936 public String getEnvironmentStat(final String statName) 937 { 938 return envStats.get(toLowerCase(statName)); 939 } 940 941 942 943 /** 944 * Retrieves a set of lock statistics for the database environment, mapped 945 * from the statistic name to the string representation of its value. The 946 * statistic names will be formatted in all lowercase characters. 947 * 948 * @return A set of lock statistics for the database environment, mapped from 949 * the statistic name to the string representation of its value. 950 */ 951 public Map<String,String> getLockStats() 952 { 953 return lockStats; 954 } 955 956 957 958 /** 959 * Retrieves the string representation of the value for a database environment 960 * lock statistic. 961 * 962 * @param statName The name of the statistic to retrieve. It will be 963 * treated in a case-insensitive manner. 964 * 965 * @return The value of the requested database environment lock statistic, or 966 * {@code null} if no such statistic was provided. 967 */ 968 public String getLockStat(final String statName) 969 { 970 return lockStats.get(toLowerCase(statName)); 971 } 972 973 974 975 /** 976 * Retrieves a set of transaction statistics for the database environment, 977 * mapped from the statistic name to the string representation of its value. 978 * The statistic names will be formatted in all lowercase characters. 979 * 980 * @return A set of transaction statistics for the database environment, 981 * mapped from the statistic name to the string representation of its 982 * value. 983 */ 984 public Map<String,String> getTransactionStats() 985 { 986 return txnStats; 987 } 988 989 990 991 /** 992 * Retrieves the string representation of the value for a database environment 993 * transaction statistic. 994 * 995 * @param statName The name of the statistic to retrieve. It will be 996 * treated in a case-insensitive manner. 997 * 998 * @return The value of the requested database environment transaction 999 * statistic, or {@code null} if no such statistic was provided. 1000 */ 1001 public String getTransactionStat(final String statName) 1002 { 1003 return txnStats.get(toLowerCase(statName)); 1004 } 1005 1006 1007 1008 /** 1009 * {@inheritDoc} 1010 */ 1011 @Override() 1012 public String getMonitorDisplayName() 1013 { 1014 return INFO_JE_ENVIRONMENT_MONITOR_DISPNAME.get(); 1015 } 1016 1017 1018 1019 /** 1020 * {@inheritDoc} 1021 */ 1022 @Override() 1023 public String getMonitorDescription() 1024 { 1025 return INFO_JE_ENVIRONMENT_MONITOR_DESC.get(); 1026 } 1027 1028 1029 1030 /** 1031 * {@inheritDoc} 1032 */ 1033 @Override() 1034 public Map<String,MonitorAttribute> getMonitorAttributes() 1035 { 1036 final LinkedHashMap<String,MonitorAttribute> attrs = 1037 new LinkedHashMap<String,MonitorAttribute>(); 1038 1039 if (backendID != null) 1040 { 1041 addMonitorAttribute(attrs, 1042 ATTR_BACKEND_ID, 1043 INFO_JE_ENVIRONMENT_DISPNAME_BACKEND_ID.get(), 1044 INFO_JE_ENVIRONMENT_DESC_BACKEND_ID.get(), 1045 backendID); 1046 } 1047 1048 if (jeVersion != null) 1049 { 1050 addMonitorAttribute(attrs, 1051 ATTR_JE_VERSION, 1052 INFO_JE_ENVIRONMENT_DISPNAME_JE_VERSION.get(), 1053 INFO_JE_ENVIRONMENT_DESC_JE_VERSION.get(), 1054 jeVersion); 1055 } 1056 1057 if (dbDirectory != null) 1058 { 1059 addMonitorAttribute(attrs, 1060 ATTR_DB_DIRECTORY, 1061 INFO_JE_ENVIRONMENT_DISPNAME_DB_DIRECTORY.get(), 1062 INFO_JE_ENVIRONMENT_DESC_DB_DIRECTORY.get(), 1063 dbDirectory); 1064 } 1065 1066 if (dbOnDiskSize != null) 1067 { 1068 addMonitorAttribute(attrs, 1069 ATTR_DB_ON_DISK_SIZE, 1070 INFO_JE_ENVIRONMENT_DISPNAME_DB_ON_DISK_SIZE.get(), 1071 INFO_JE_ENVIRONMENT_DESC_DB_ON_DISK_SIZE.get(), 1072 dbOnDiskSize); 1073 } 1074 1075 if (currentDBCacheSize != null) 1076 { 1077 addMonitorAttribute(attrs, 1078 ATTR_CURRENT_CACHE_SIZE, 1079 INFO_JE_ENVIRONMENT_DISPNAME_CURRENT_CACHE_SIZE.get(), 1080 INFO_JE_ENVIRONMENT_DESC_CURRENT_CACHE_SIZE.get(), 1081 currentDBCacheSize); 1082 } 1083 1084 if (maxDBCacheSize != null) 1085 { 1086 addMonitorAttribute(attrs, 1087 ATTR_MAX_CACHE_SIZE, 1088 INFO_JE_ENVIRONMENT_DISPNAME_MAX_CACHE_SIZE.get(), 1089 INFO_JE_ENVIRONMENT_DESC_MAX_CACHE_SIZE.get(), 1090 maxDBCacheSize); 1091 } 1092 1093 if (dbCachePercentFull != null) 1094 { 1095 addMonitorAttribute(attrs, 1096 ATTR_CACHE_PCT_FULL, 1097 INFO_JE_ENVIRONMENT_DISPNAME_CACHE_PCT_FULL.get(), 1098 INFO_JE_ENVIRONMENT_DESC_CACHE_PCT_FULL.get(), 1099 dbCachePercentFull); 1100 } 1101 1102 if (checkpointInProgress != null) 1103 { 1104 addMonitorAttribute(attrs, 1105 ATTR_CHECKPOINT_IN_PROGRESS, 1106 INFO_JE_ENVIRONMENT_DISPNAME_CP_IN_PROGRESS.get(), 1107 INFO_JE_ENVIRONMENT_DESC_CP_IN_PROGRESS.get(), 1108 checkpointInProgress); 1109 } 1110 1111 if (numCheckpoints != null) 1112 { 1113 addMonitorAttribute(attrs, 1114 ATTR_NUM_CHECKPOINTS, 1115 INFO_JE_ENVIRONMENT_DISPNAME_NUM_CP.get(), 1116 INFO_JE_ENVIRONMENT_DESC_NUM_CP.get(), 1117 numCheckpoints); 1118 } 1119 1120 if (totalCheckpointDurationMillis != null) 1121 { 1122 addMonitorAttribute(attrs, 1123 ATTR_TOTAL_CHECKPOINT_DURATION_MILLIS, 1124 INFO_JE_ENVIRONMENT_DISPNAME_TOTAL_CP_DURATION.get(), 1125 INFO_JE_ENVIRONMENT_DESC_TOTAL_CP_DURATION.get(), 1126 totalCheckpointDurationMillis); 1127 } 1128 1129 if (averageCheckpointDurationMillis != null) 1130 { 1131 addMonitorAttribute(attrs, 1132 ATTR_AVERAGE_CHECKPOINT_DURATION_MILLIS, 1133 INFO_JE_ENVIRONMENT_DISPNAME_AVG_CP_DURATION.get(), 1134 INFO_JE_ENVIRONMENT_DESC_AVG_CP_DURATION.get(), 1135 averageCheckpointDurationMillis); 1136 } 1137 1138 if (lastCheckpointDurationMillis != null) 1139 { 1140 addMonitorAttribute(attrs, 1141 ATTR_LAST_CHECKPOINT_DURATION_MILLIS, 1142 INFO_JE_ENVIRONMENT_DISPNAME_LAST_CP_DURATION.get(), 1143 INFO_JE_ENVIRONMENT_DESC_LAST_CP_DURATION.get(), 1144 lastCheckpointDurationMillis); 1145 } 1146 1147 if (lastCheckpointStartTime != null) 1148 { 1149 addMonitorAttribute(attrs, 1150 ATTR_LAST_CHECKPOINT_START_TIME, 1151 INFO_JE_ENVIRONMENT_DISPNAME_LAST_CP_START_TIME.get(), 1152 INFO_JE_ENVIRONMENT_DESC_LAST_CP_START_TIME.get(), 1153 lastCheckpointStartTime); 1154 } 1155 1156 if (lastCheckpointStopTime != null) 1157 { 1158 addMonitorAttribute(attrs, 1159 ATTR_LAST_CHECKPOINT_STOP_TIME, 1160 INFO_JE_ENVIRONMENT_DISPNAME_LAST_CP_STOP_TIME.get(), 1161 INFO_JE_ENVIRONMENT_DESC_LAST_CP_STOP_TIME.get(), 1162 lastCheckpointStopTime); 1163 } 1164 1165 if (millisSinceLastCheckpoint != null) 1166 { 1167 addMonitorAttribute(attrs, 1168 ATTR_MILLIS_SINCE_LAST_CHECKPOINT, 1169 INFO_JE_ENVIRONMENT_DISPNAME_MILLIS_SINCE_CP.get(), 1170 INFO_JE_ENVIRONMENT_DESC_MILLIS_SINCE_CP.get(), 1171 millisSinceLastCheckpoint); 1172 } 1173 1174 if (cleanerBacklog != null) 1175 { 1176 addMonitorAttribute(attrs, 1177 ATTR_CLEANER_BACKLOG, 1178 INFO_JE_ENVIRONMENT_DISPNAME_CLEANER_BACKLOG.get(), 1179 INFO_JE_ENVIRONMENT_DESC_CLEANER_BACKLOG.get(), 1180 cleanerBacklog); 1181 } 1182 1183 if (nodesEvicted != null) 1184 { 1185 addMonitorAttribute(attrs, 1186 ATTR_NODES_EVICTED, 1187 INFO_JE_ENVIRONMENT_DISPNAME_NODES_EVICTED.get(), 1188 INFO_JE_ENVIRONMENT_DESC_NODES_EVICTED.get(), 1189 nodesEvicted); 1190 } 1191 1192 if (randomReads != null) 1193 { 1194 addMonitorAttribute(attrs, 1195 ATTR_RANDOM_READS, 1196 INFO_JE_ENVIRONMENT_DISPNAME_RANDOM_READS.get(), 1197 INFO_JE_ENVIRONMENT_DESC_RANDOM_READS.get(), 1198 randomReads); 1199 } 1200 1201 if (randomWrites != null) 1202 { 1203 addMonitorAttribute(attrs, 1204 ATTR_RANDOM_WRITES, 1205 INFO_JE_ENVIRONMENT_DISPNAME_RANDOM_WRITES.get(), 1206 INFO_JE_ENVIRONMENT_DESC_RANDOM_WRITES.get(), 1207 randomWrites); 1208 } 1209 1210 if (sequentialReads != null) 1211 { 1212 addMonitorAttribute(attrs, 1213 ATTR_SEQUENTIAL_READS, 1214 INFO_JE_ENVIRONMENT_DISPNAME_SEQUENTIAL_READS.get(), 1215 INFO_JE_ENVIRONMENT_DESC_SEQUENTIAL_READS.get(), 1216 sequentialReads); 1217 } 1218 1219 if (sequentialWrites != null) 1220 { 1221 addMonitorAttribute(attrs, 1222 ATTR_SEQUENTIAL_WRITES, 1223 INFO_JE_ENVIRONMENT_DISPNAME_SEQUENTIAL_WRITES.get(), 1224 INFO_JE_ENVIRONMENT_DESC_SEQUENTIAL_WRITES.get(), 1225 sequentialWrites); 1226 } 1227 1228 if (activeTransactionCount != null) 1229 { 1230 addMonitorAttribute(attrs, 1231 ATTR_ACTIVE_TXNS, 1232 INFO_JE_ENVIRONMENT_DISPNAME_ACTIVE_TXNS.get(), 1233 INFO_JE_ENVIRONMENT_DESC_ACTIVE_TXNS.get(), 1234 activeTransactionCount); 1235 } 1236 1237 if (readLocksHeld != null) 1238 { 1239 addMonitorAttribute(attrs, 1240 ATTR_NUM_READ_LOCKS, 1241 INFO_JE_ENVIRONMENT_DISPNAME_READ_LOCKS.get(), 1242 INFO_JE_ENVIRONMENT_DESC_READ_LOCKS.get(), 1243 readLocksHeld); 1244 } 1245 1246 if (writeLocksHeld != null) 1247 { 1248 addMonitorAttribute(attrs, 1249 ATTR_NUM_WRITE_LOCKS, 1250 INFO_JE_ENVIRONMENT_DISPNAME_WRITE_LOCKS.get(), 1251 INFO_JE_ENVIRONMENT_DESC_WRITE_LOCKS.get(), 1252 writeLocksHeld); 1253 } 1254 1255 if (transactionsWaitingOnLocks != null) 1256 { 1257 addMonitorAttribute(attrs, 1258 ATTR_NUM_WAITING_TXNS, 1259 INFO_JE_ENVIRONMENT_DISPNAME_TXNS_WAITING_ON_LOCKS.get(), 1260 INFO_JE_ENVIRONMENT_DESC_TXNS_WAITING_ON_LOCKS.get(), 1261 transactionsWaitingOnLocks); 1262 } 1263 1264 if (! envStats.isEmpty()) 1265 { 1266 final ArrayList<String> values = new ArrayList<String>(envStats.size()); 1267 for (final Map.Entry<String,String> e : envStats.entrySet()) 1268 { 1269 values.add(e.getKey() + '=' + e.getValue()); 1270 } 1271 1272 addMonitorAttribute(attrs, 1273 PROPERTY_ENV_STATS, 1274 INFO_JE_ENVIRONMENT_DISPNAME_ENV_STATS.get(), 1275 INFO_JE_ENVIRONMENT_DESC_ENV_STATS.get(), 1276 values); 1277 } 1278 1279 if (! lockStats.isEmpty()) 1280 { 1281 final ArrayList<String> values = new ArrayList<String>(lockStats.size()); 1282 for (final Map.Entry<String,String> e : lockStats.entrySet()) 1283 { 1284 values.add(e.getKey() + '=' + e.getValue()); 1285 } 1286 1287 addMonitorAttribute(attrs, 1288 PROPERTY_LOCK_STATS, 1289 INFO_JE_ENVIRONMENT_DISPNAME_LOCK_STATS.get(), 1290 INFO_JE_ENVIRONMENT_DESC_LOCK_STATS.get(), 1291 values); 1292 } 1293 1294 if (! txnStats.isEmpty()) 1295 { 1296 final ArrayList<String> values = new ArrayList<String>(txnStats.size()); 1297 for (final Map.Entry<String,String> e : txnStats.entrySet()) 1298 { 1299 values.add(e.getKey() + '=' + e.getValue()); 1300 } 1301 1302 addMonitorAttribute(attrs, 1303 PROPERTY_TXN_STATS, 1304 INFO_JE_ENVIRONMENT_DISPNAME_TXN_STATS.get(), 1305 INFO_JE_ENVIRONMENT_DESC_TXN_STATS.get(), 1306 values); 1307 } 1308 1309 return Collections.unmodifiableMap(attrs); 1310 } 1311 }